@bytecodealliance/preview2-shim 0.18.1 → 0.20.0

package/lib/browser/io.js

@@ -1,262 +0,0 @@
-let id = 0;
-
-const symbolDispose = Symbol.dispose || Symbol.for("dispose");
-
-const IoError = class Error {
-  constructor(msg) {
-    this.msg = msg;
-  }
-  toDebugString() {
-    return this.msg;
-  }
-};
-
-/**
- * @typedef {{
- *   read?: (len: BigInt) => Uint8Array,
- *   blockingRead: (len: BigInt) => Uint8Array,
- *   skip?: (len: BigInt) => BigInt,
- *   blockingSkip?: (len: BigInt) => BigInt,
- *   subscribe: () => Pollable,
- *   drop?: () => void,
- * }} InputStreamHandler
- *
- * @typedef {{
- *   checkWrite?: () -> BigInt,
- *   write: (buf: Uint8Array) => BigInt,
- *   blockingWriteAndFlush?: (buf: Uint8Array) => void,
- *   flush?: () => void,
- *   blockingFlush: () => void,
- *   writeZeroes?: (len: BigInt) => void,
- *   blockingWriteZeroes?: (len: BigInt) => void,
- *   blockingWriteZeroesAndFlush?: (len: BigInt) => void,
- *   splice?: (src: InputStream, len: BigInt) => BigInt,
- *   blockingSplice?: (src: InputStream, len: BigInt) => BigInt,
- *   forward?: (src: InputStream) => void,
- *   subscribe?: () => Pollable,
- *   drop?: () => void,
- * }} OutputStreamHandler
- *
- **/
-
-class InputStream {
-  /**
-   * @param {InputStreamHandler} handler
-   */
-  constructor(handler) {
-    if (!handler) {
-      console.trace("no handler");
-    }
-    this.id = ++id;
-    this.handler = handler;
-  }
-  read(len) {
-    if (this.handler.read) {
-      return this.handler.read(len);
-    }
-    return this.handler.blockingRead.call(this, len);
-  }
-  blockingRead(len) {
-    return this.handler.blockingRead.call(this, len);
-  }
-  skip(len) {
-    if (this.handler.skip) {
-      return this.handler.skip.call(this, len);
-    }
-    if (this.handler.read) {
-      const bytes = this.handler.read.call(this, len);
-      return BigInt(bytes.byteLength);
-    }
-    return this.blockingSkip.call(this, len);
-  }
-  blockingSkip(len) {
-    if (this.handler.blockingSkip) {
-      return this.handler.blockingSkip.call(this, len);
-    }
-    const bytes = this.handler.blockingRead.call(this, len);
-    return BigInt(bytes.byteLength);
-  }
-  subscribe() {
-    if (this.handler.subscribe) {
-      return this.handler.subscribe();
-    }
-    return new Pollable();
-  }
-  [symbolDispose]() {
-    if (this.handler.drop) {
-      this.handler.drop.call(this);
-    }
-  }
-}
-
-class OutputStream {
-  /**
-   * @param {OutputStreamHandler} handler
-   */
-  constructor(handler) {
-    if (!handler) {
-      console.trace("no handler");
-    }
-    this.id = ++id;
-    this.open = true;
-    this.handler = handler;
-  }
-  checkWrite(len) {
-    if (!this.open) {
-      return 0n;
-    }
-    if (this.handler.checkWrite) {
-      return this.handler.checkWrite.call(this, len);
-    }
-    return 1_000_000n;
-  }
-  write(buf) {
-    this.handler.write.call(this, buf);
-  }
-  blockingWriteAndFlush(buf) {
-    /// Perform a write of up to 4096 bytes, and then flush the stream. Block
-    /// until all of these operations are complete, or an error occurs.
-    ///
-    /// This is a convenience wrapper around the use of `check-write`,
-    /// `subscribe`, `write`, and `flush`, and is implemented with the
-    /// following pseudo-code:
-    ///
-    /// ```text
-    /// let pollable = this.subscribe();
-    /// while !contents.is_empty() {
-    ///     // Wait for the stream to become writable
-    ///     poll-one(pollable);
-    ///     let Ok(n) = this.check-write(); // eliding error handling
-    ///     let len = min(n, contents.len());
-    ///     let (chunk, rest) = contents.split_at(len);
-    ///     this.write(chunk  );            // eliding error handling
-    ///     contents = rest;
-    /// }
-    /// this.flush();
-    /// // Wait for completion of `flush`
-    /// poll-one(pollable);
-    /// // Check for any errors that arose during `flush`
-    /// let _ = this.check-write();         // eliding error handling
-    /// ```
-    this.handler.write.call(this, buf);
-  }
-  flush() {
-    if (this.handler.flush) {
-      this.handler.flush.call(this);
-    }
-  }
-  blockingFlush() {
-    this.open = true;
-  }
-  writeZeroes(len) {
-    this.write.call(this, new Uint8Array(Number(len)));
-  }
-  blockingWriteZeroes(len) {
-    this.blockingWrite.call(this, new Uint8Array(Number(len)));
-  }
-  blockingWriteZeroesAndFlush(len) {
-    this.blockingWriteAndFlush.call(this, new Uint8Array(Number(len)));
-  }
-  splice(src, len) {
-    const spliceLen = Math.min(len, this.checkWrite.call(this));
-    const bytes = src.read(spliceLen);
-    this.write.call(this, bytes);
-    return bytes.byteLength;
-  }
-  blockingSplice(_src, _len) {
-    console.log(`[streams] Blocking splice ${this.id}`);
-  }
-  forward(_src) {
-    console.log(`[streams] Forward ${this.id}`);
-  }
-  subscribe() {
-    if (this.handler.subscribe) {
-      return this.handler.subscribe();
-    }
-    return new Pollable();
-  }
-  [symbolDispose]() {}
-}
-
-export const error = { Error: IoError };
-
-export const streams = { InputStream, OutputStream };
-
-class Pollable {
-  #ready = false;
-  #promise = null;
-
-  constructor(promise) {
-    if (!promise) {
-      this.#ready = true;
-    } else {
-      this.#promise = promise.then(
-        () => {
-          this.#ready = true;
-        },
-        () => {
-          this.#ready = true;
-        },
-      );
-    }
-  }
-
-  ready() {
-    return this.#ready;
-  }
-
-  block() {
-    if (this.#ready) {
-      return Promise.resolve();
-    }
-    return this.#promise;
-  }
-
-  [symbolDispose]() {
-    this.#promise = null;
-  }
-}
-
-function pollList(list) {
-  if (list.length === 0) {
-    throw new Error("poll list must not be empty");
-  }
-  if (list.length > 0xffffffff) {
-    throw new Error("poll list length exceeds u32 index range");
-  }
-  const ready = [];
-  for (let i = 0; i < list.length; i++) {
-    if (list[i].ready()) {
-      ready.push(i);
-    }
-  }
-  if (ready.length > 0) {
-    return new Uint32Array(ready);
-  }
-  // None ready synchronously. Wait for the first to resolve via Promise.race,
-  // then sweep for any others that became ready concurrently.
-  return Promise.race(
-    list.map((p, i) =>
-      p.block().then(() => {
-        const result = [i];
-        for (let j = 0; j < list.length; j++) {
-          if (j !== i && list[j].ready()) {
-            result.push(j);
-          }
-        }
-        return new Uint32Array(result);
-      }),
-    ),
-  );
-}
-
-function pollOne(poll) {
-  return poll.block();
-}
-
-export const poll = {
-  Pollable,
-  pollList,
-  pollOne,
-  poll: pollList,
-};

package/lib/browser/random.js

@@ -1,56 +0,0 @@
-const MAX_BYTES = 65536;
-
-let insecureRandomValue1, insecureRandomValue2;
-
-export const insecure = {
-  getInsecureRandomBytes(len) {
-    return random.getRandomBytes(len);
-  },
-  getInsecureRandomU64() {
-    return random.getRandomU64();
-  },
-};
-
-let insecureSeedValue1, insecureSeedValue2;
-
-export const insecureSeed = {
-  insecureSeed() {
-    if (insecureSeedValue1 === undefined) {
-      insecureSeedValue1 = random.getRandomU64();
-      insecureSeedValue2 = random.getRandomU64();
-    }
-    return [insecureSeedValue1, insecureSeedValue2];
-  },
-};
-
-export const random = {
-  getRandomBytes(len) {
-    const bytes = new Uint8Array(Number(len));
-
-    if (len > MAX_BYTES) {
-      // this is the max bytes crypto.getRandomValues
-      // can do at once see https://developer.mozilla.org/en-US/docs/Web/API/window.crypto.getRandomValues
-      for (var generated = 0; generated < len; generated += MAX_BYTES) {
-        // buffer.slice automatically checks if the end is past the end of
-        // the buffer so we don't have to here
-        crypto.getRandomValues(bytes.subarray(generated, generated + MAX_BYTES));
-      }
-    } else {
-      crypto.getRandomValues(bytes);
-    }
-
-    return bytes;
-  },
-
-  getRandomU64() {
-    return crypto.getRandomValues(new BigUint64Array(1))[0];
-  },
-
-  insecureRandom() {
-    if (insecureRandomValue1 === undefined) {
-      insecureRandomValue1 = random.getRandomU64();
-      insecureRandomValue2 = random.getRandomU64();
-    }
-    return [insecureRandomValue1, insecureRandomValue2];
-  },
-};

package/lib/browser/sockets.js

@@ -1,88 +0,0 @@
-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() {},
-  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() {},
-
-  unicastHopLimit() {},
-
-  setUnicastHopLimit() {},
-
-  receiveBufferSize() {},
-
-  setReceiveBufferSize() {},
-
-  sendBufferSize() {},
-
-  setSendBufferSize() {},
-
-  nonBlocking() {},
-
-  setNonBlocking() {},
-};
-
-export const udpCreateSocket = {
-  createUdpSocket() {},
-};

package/lib/common/instantiation.js

@@ -1,253 +0,0 @@
-import * as wasi from "@bytecodealliance/preview2-shim";
-
-/**
- * (EXPERIMENTAL) A class that holds WASI shims and can be used to configure
- * an instantiation of a WebAssembly component transpiled with jco
- * (i.e. via `jco transpile`).
- *
- * Normally, transpiled components contain mapping for WASI interfaces
- * and/or imports that import the relevant packages (ex. `@bytecodealliance/preview2-shim/clocks`)
- * from the right sources.
- *
- * This function makes use of the `WASIShim` object to provide an object that can be easily
- * fed to the `instantiate` function produced by a transpiled component:
- *
- * ```js
- * import { WASIShim } from "@bytecodealliance/preview2-shim/instantiation"
- * // ...
- * import { instantiate } from "path/to/transpiled/component.js"
- * // ...
- * const component = await instantiate(null, new WASIShim().getImportObject())
- * ```
- *
- * You can also replace imports that you'd like to override with custom implementations,
- * by using the `WASIShim` object directly:
- *
- * ```js
- * import { random } from "@bytecodealliance/preview2-shim"
- * import { WASIShim } from "@bytecodealliance/preview2-shim/instantiation"
- * // ...
- * import { instantiate } from "path/to/transpiled/component.js"
- * // ...
- * const customWASIShim = new WASIShim({
- *     random: {
- *         // For these two interfaces we re-use the default provided shim
- *         random: random.random,
- *         insecure-seed: random.insecureSeed,
- *         // For insecure, we can supply our own custom implementation
- *         insecure: {
- *             ...
- *         }
- *     }
- * });
- *
- * const component = await instantiate(null, customWASIShim.getImportObject())
- * ```
- *
- * For sandboxing, you can configure preopens, environment variables, and other
- * capabilities via the `sandbox` option:
- *
- * ```js
- * import { WASIShim } from "@bytecodealliance/preview2-shim/instantiation"
- *
- * // Fully sandboxed - no filesystem, network, or env access
- * const sandboxedShim = new WASIShim({
- *   sandbox: {
- *     preopens: {},           // No filesystem access
- *     env: {},                // No environment variables
- *     args: ['program'],      // Custom arguments
- *     enableNetwork: false,   // Disable network (default: true for backward compat)
- *   }
- * });
- *
- * // Limited filesystem access
- * const limitedShim = new WASIShim({
- *   sandbox: {
- *     preopens: {
- *       '/data': '/tmp/guest-data',  // Guest sees /data, maps to /tmp/guest-data
- *       '/config': '/etc/app'        // Guest sees /config, maps to /etc/app
- *     }
- *   }
- * });
- * ```
- *
- * Note that this object is similar but not identical to the Node `WASI` object --
- * it is solely concerned with shimming of preview2 when dealing with a WebAssembly
- * component transpiled by Jco. While this object *does* work with Node (and the browser)
- * semantics are not the same as Node's `WASI` object.
- *
- * @class WASIShim
- */
-export class WASIShim {
-  /** Object that confirms to the shim interface for `wasi:cli` */
-  #cli;
-  /** Object that confirms to the shim interface for `wasi:filesystem` */
-  #filesystem;
-  /** Object that confirms to the shim interface for `wasi:io` */
-  #io;
-  /** Object that confirms to the shim interface for `wasi:random` */
-  #random;
-  /** Object that confirms to the shim interface for `wasi:clocks` */
-  #clocks;
-  /** Object that confirms to the shim interface for `wasi:sockets` */
-  #sockets;
-  /** Object that confirms to the shim interface for `wasi:http` */
-  #http;
-  /** Isolated preopens for this instance */
-  #preopens;
-  /** Isolated environment for this instance */
-  #environment;
-
-  /**
-   * Create a new WASIShim instance.
-   *
-   * @param {import('../types/instantiation.d.ts').WASIShimConfig} [config] - Configuration options
-   */
-  constructor(config) {
-    // Support both old 'shims' parameter name and new 'config' style
-    const shims = config;
-
-    this.#cli = shims?.cli ?? wasi.cli;
-    this.#filesystem = shims?.filesystem ?? wasi.filesystem;
-    this.#io = shims?.io ?? wasi.io;
-    this.#random = shims?.random ?? wasi.random;
-    this.#clocks = shims?.clocks ?? wasi.clocks;
-    this.#sockets = shims?.sockets ?? wasi.sockets;
-    this.#http = shims?.http ?? wasi.http;
-
-    // Extract sandbox options
-    const sandbox = shims?.sandbox;
-
-    // Create isolated preopens if configured
-    if (sandbox?.preopens !== undefined) {
-      this.#preopens = createIsolatedPreopens(sandbox.preopens);
-    }
-
-    // Create isolated environment if env or args are configured
-    if (sandbox?.env !== undefined || sandbox?.args !== undefined) {
-      this.#environment = createIsolatedEnvironment(sandbox?.env, sandbox?.args, this.#cli);
-    }
-
-    // Apply network restrictions if disabled
-    if (sandbox?.enableNetwork === false) {
-      // Use the sockets module's built-in deny functions
-      if (this.#sockets._denyTcp) {
-        this.#sockets._denyTcp();
-      }
-      if (this.#sockets._denyUdp) {
-        this.#sockets._denyUdp();
-      }
-      if (this.#sockets._denyDnsLookup) {
-        this.#sockets._denyDnsLookup();
-      }
-    }
-  }
-
-  /**
-   * Generate an import object for the shim that can be used with
-   * functions like `instantiate` that are exposed from a transpiled
-   * WebAssembly component.
-   *
-   * @param {GetImportObjectArgs} [opts] - options for import object generation
-   * @returns {WASIImportObject}
-   *
-   * @typedef {{
-   *   asVersion?: number,
-   * }} GetImportObjectArgs
-   */
-  getImportObject(opts) {
-    const versionSuffix = opts?.asVersion ? `@${opts.asVersion}` : "";
-
-    const obj = {};
-
-    obj[`wasi:cli/environment${versionSuffix}`] = this.#environment ?? this.#cli.environment;
-    obj[`wasi:cli/exit${versionSuffix}`] = this.#cli.exit;
-    obj[`wasi:cli/stderr${versionSuffix}`] = this.#cli.stderr;
-    obj[`wasi:cli/stdin${versionSuffix}`] = this.#cli.stdin;
-    obj[`wasi:cli/stdout${versionSuffix}`] = this.#cli.stdout;
-    obj[`wasi:cli/terminal-input${versionSuffix}`] = this.#cli.terminalInput;
-    obj[`wasi:cli/terminal-output${versionSuffix}`] = this.#cli.terminalOutput;
-    obj[`wasi:cli/terminal-stderr${versionSuffix}`] = this.#cli.terminalStderr;
-    obj[`wasi:cli/terminal-stdin${versionSuffix}`] = this.#cli.terminalStdin;
-    obj[`wasi:cli/terminal-stdout${versionSuffix}`] = this.#cli.terminalStdout;
-
-    obj[`wasi:sockets/instance-network${versionSuffix}`] = this.#sockets.instanceNetwork;
-    obj[`wasi:sockets/ip-name-lookup${versionSuffix}`] = this.#sockets.ipNameLookup;
-    obj[`wasi:sockets/network${versionSuffix}`] = this.#sockets.network;
-    obj[`wasi:sockets/tcp${versionSuffix}`] = this.#sockets.tcp;
-    obj[`wasi:sockets/tcp-create-socket${versionSuffix}`] = this.#sockets.tcpCreateSocket;
-    obj[`wasi:sockets/udp${versionSuffix}`] = this.#sockets.udp;
-    obj[`wasi:sockets/udp-create-socket${versionSuffix}`] = this.#sockets.udpCreateSocket;
-
-    obj[`wasi:filesystem/preopens${versionSuffix}`] = this.#preopens ?? this.#filesystem.preopens;
-    obj[`wasi:filesystem/types${versionSuffix}`] = this.#filesystem.types;
-
-    obj[`wasi:io/error${versionSuffix}`] = this.#io.error;
-    obj[`wasi:io/poll${versionSuffix}`] = this.#io.poll;
-    obj[`wasi:io/streams${versionSuffix}`] = this.#io.streams;
-
-    obj[`wasi:random/random${versionSuffix}`] = this.#random.random;
-    obj[`wasi:random/insecure${versionSuffix}`] = this.#random.insecure;
-    obj[`wasi:random/insecure-seed${versionSuffix}`] = this.#random.insecureSeed;
-
-    obj[`wasi:clocks/monotonic-clock${versionSuffix}`] = this.#clocks.monotonicClock;
-    obj[`wasi:clocks/wall-clock${versionSuffix}`] = this.#clocks.wallClock;
-
-    obj[`wasi:http/types${versionSuffix}`] = this.#http.types;
-    obj[`wasi:http/outgoing-handler${versionSuffix}`] = this.#http.outgoingHandler;
-
-    return obj;
-  }
-}
-
-/**
- * Create an isolated preopens object with its own preopen entries.
- *
- * @param {Record<string, string>} preopensConfig - Map of virtual paths to host paths
- * @returns {object} A preopens object with Descriptor and getDirectories()
- */
-function createIsolatedPreopens(preopensConfig) {
-  const { types, _createPreopenDescriptor } = wasi.filesystem;
-  const entries = [];
-
-  // Populate entries using the filesystem's descriptor creation
-  if (_createPreopenDescriptor) {
-    for (const [virtualPath, hostPath] of Object.entries(preopensConfig)) {
-      const descriptor = _createPreopenDescriptor(hostPath);
-      entries.push([descriptor, virtualPath]);
-    }
-  }
-
-  return {
-    Descriptor: types.Descriptor,
-    getDirectories() {
-      return entries;
-    },
-  };
-}
-
-/**
- * Create an isolated CLI environment with its own env and args.
- *
- * @param {Record<string, string>} env - Environment variables
- * @param {string[]} args - Command-line arguments
- * @param {object} baseCli - The base CLI module to extend
- * @returns {object} An isolated CLI environment object
- */
-function createIsolatedEnvironment(env, args, baseCli) {
-  const envEntries = env ? Object.entries(env) : null;
-  const argsArray = args || null;
-
-  return {
-    ...baseCli.environment,
-    getEnvironment() {
-      return envEntries ?? baseCli.environment.getEnvironment();
-    },
-    getArguments() {
-      return argsArray ?? baseCli.environment.getArguments();
-    },
-    initialCwd() {
-      return baseCli.environment.initialCwd();
-    },
-  };
-}