@bytecodealliance/preview2-shim 0.0.12 → 0.0.14

package/types/exports/wasi-http-incoming-handler.d.ts

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

package/types/exports/wasi-http-outgoing-handler.d.ts

@@ -0,0 +1,9 @@
+export namespace WasiHttpOutgoingHandler {
+  export function handle(request: OutgoingRequest, options: RequestOptions | null): FutureIncomingResponse;
+}
+import type { OutgoingRequest } from '../exports/wasi-http-types';
+export { OutgoingRequest };
+import type { RequestOptions } from '../exports/wasi-http-types';
+export { RequestOptions };
+import type { FutureIncomingResponse } from '../exports/wasi-http-types';
+export { FutureIncomingResponse };

package/types/{imports/types.d.ts → exports/wasi-http-types.d.ts}

@@ -1,27 +1,26 @@
-export namespace ImportsTypes {
+export namespace WasiHttpTypes {
   export function dropFields(fields: Fields): void;
   export function newFields(entries: [string, string][]): Fields;
-  export function fieldsGet(fields: Fields, name: string): string[];
-  export function fieldsSet(fields: Fields, name: string, value: string[]): void;
+  export function fieldsGet(fields: Fields, name: string): Uint8Array[];
+  export function fieldsSet(fields: Fields, name: string, value: Uint8Array | ArrayBuffer[]): void;
   export function fieldsDelete(fields: Fields, name: string): void;
-  export function fieldsAppend(fields: Fields, name: string, value: string): void;
-  export function fieldsEntries(fields: Fields): [string, string][];
+  export function fieldsAppend(fields: Fields, name: string, value: Uint8Array | ArrayBuffer): void;
+  export function fieldsEntries(fields: Fields): [string, Uint8Array][];
   export function fieldsClone(fields: Fields): Fields;
   export function finishIncomingStream(s: IncomingStream): Trailers | null;
   export function finishOutgoingStream(s: OutgoingStream, trailers: Trailers | null): void;
   export function dropIncomingRequest(request: IncomingRequest): void;
   export function dropOutgoingRequest(request: OutgoingRequest): void;
   export function incomingRequestMethod(request: IncomingRequest): Method;
-  export function incomingRequestPath(request: IncomingRequest): string;
-  export function incomingRequestQuery(request: IncomingRequest): string;
+  export function incomingRequestPathWithQuery(request: IncomingRequest): string | null;
   export function incomingRequestScheme(request: IncomingRequest): Scheme | null;
-  export function incomingRequestAuthority(request: IncomingRequest): string;
+  export function incomingRequestAuthority(request: IncomingRequest): string | null;
   export function incomingRequestHeaders(request: IncomingRequest): Headers;
   export function incomingRequestConsume(request: IncomingRequest): IncomingStream;
-  export function newOutgoingRequest(method: Method, path: string, query: string, scheme: Scheme | null, authority: string, headers: Headers): OutgoingRequest;
+  export function newOutgoingRequest(method: Method, pathWithQuery: string | null, scheme: Scheme | null, authority: string | null, headers: Headers): OutgoingRequest;
   export function outgoingRequestWrite(request: OutgoingRequest): OutgoingStream;
   export function dropResponseOutparam(response: ResponseOutparam): void;
-  export function setResponseOutparam(response: Result<OutgoingResponse, Error>): void;
+  export function setResponseOutparam(param: ResponseOutparam, response: Result<OutgoingResponse, Error>): void;
   export function dropIncomingResponse(response: IncomingResponse): void;
   export function dropOutgoingResponse(response: OutgoingResponse): void;
   export function incomingResponseStatus(response: IncomingResponse): StatusCode;
@@ -33,33 +32,12 @@ export namespace ImportsTypes {
   export function futureIncomingResponseGet(f: FutureIncomingResponse): Result<IncomingResponse, Error> | null;
   export function listenToFutureIncomingResponse(f: FutureIncomingResponse): Pollable;
 }
-import type { InputStream } from '../imports/streams';
+import type { InputStream } from '../exports/wasi-io-streams';
 export { InputStream };
-import type { OutputStream } from '../imports/streams';
+import type { OutputStream } from '../exports/wasi-io-streams';
 export { OutputStream };
-import type { Pollable } from '../imports/poll';
+import type { Pollable } from '../exports/wasi-poll-poll';
 export { Pollable };
-export type StatusCode = number;
-export type Scheme = SchemeHttp | SchemeHttps | SchemeOther;
-export interface SchemeHttp {
-  tag: 'HTTP',
-}
-export interface SchemeHttps {
-  tag: 'HTTPS',
-}
-export interface SchemeOther {
-  tag: 'other',
-  val: string,
-}
-export type ResponseOutparam = number;
-export interface RequestOptions {
-  connectTimeoutMs?: number,
-  firstByteTimeoutMs?: number,
-  betweenBytesTimeoutMs?: number,
-}
-export type OutgoingStream = OutputStream;
-export type OutgoingResponse = number;
-export type OutgoingRequest = number;
 export type Method = MethodGet | MethodHead | MethodPost | MethodPut | MethodDelete | MethodConnect | MethodOptions | MethodTrace | MethodPatch | MethodOther;
 export interface MethodGet {
   tag: 'get',
@@ -92,13 +70,17 @@ export interface MethodOther {
   tag: 'other',
   val: string,
 }
-export type IncomingStream = InputStream;
-export type IncomingResponse = number;
-export type IncomingRequest = number;
-export type FutureIncomingResponse = number;
-export type Fields = number;
-export type Trailers = Fields;
-export type Headers = Fields;
+export type Scheme = SchemeHttp | SchemeHttps | SchemeOther;
+export interface SchemeHttp {
+  tag: 'HTTP',
+}
+export interface SchemeHttps {
+  tag: 'HTTPS',
+}
+export interface SchemeOther {
+  tag: 'other',
+  val: string,
+}
 export type Error = ErrorInvalidUrl | ErrorTimeoutError | ErrorProtocolError | ErrorUnexpectedError;
 export interface ErrorInvalidUrl {
   tag: 'invalid-url',
@@ -116,4 +98,21 @@ export interface ErrorUnexpectedError {
   tag: 'unexpected-error',
   val: string,
 }
+export type Fields = number;
+export type Headers = Fields;
+export type Trailers = Fields;
+export type IncomingStream = InputStream;
+export type OutgoingStream = OutputStream;
+export type IncomingRequest = number;
+export type OutgoingRequest = number;
+export interface RequestOptions {
+  connectTimeoutMs?: number,
+  firstByteTimeoutMs?: number,
+  betweenBytesTimeoutMs?: number,
+}
+export type ResponseOutparam = number;
+export type StatusCode = number;
+export type IncomingResponse = number;
+export type OutgoingResponse = number;
+export type FutureIncomingResponse = number;
 export type Result<T, E> = { tag: 'ok', val: T } | { tag: 'err', val: E };

package/types/exports/wasi-io-streams.d.ts

@@ -0,0 +1,220 @@
+export namespace WasiIoStreams {
+  /**
+   * Perform a non-blocking read from the stream.
+   * 
+   * This function returns a list of bytes containing the data that was
+   * read, along with a `stream-status` which, indicates whether further
+   * reads are expected to produce data. The returned list will contain up to
+   * `len` bytes; it may return fewer than requested, but not more. An
+   * empty list and `stream-status:open` indicates no more data is
+   * available at this time, and that the pollable given by
+   * `subscribe-to-input-stream` will be ready when more data is available.
+   * 
+   * Once a stream has reached the end, subsequent calls to `read` or
+   * `skip` will always report `stream-status:ended` rather than producing more
+   * data.
+   * 
+   * When the caller gives a `len` of 0, it represents a request to read 0
+   * bytes. This read should  always succeed and return an empty list and
+   * the current `stream-status`.
+   * 
+   * The `len` parameter is a `u64`, which could represent a list of u8 which
+   * is not possible to allocate in wasm32, or not desirable to allocate as
+   * as a return value by the callee. The callee may return a list of bytes
+   * less than `len` in size while more bytes are available for reading.
+   */
+  export function read(this_: InputStream, len: bigint): [Uint8Array, StreamStatus];
+  /**
+   * Read bytes from a stream, after blocking until at least one byte can
+   * be read. Except for blocking, identical to `read`.
+   */
+  export function blockingRead(this_: InputStream, len: bigint): [Uint8Array, StreamStatus];
+  /**
+   * Skip bytes from a stream.
+   * 
+   * This is similar to the `read` function, but avoids copying the
+   * bytes into the instance.
+   * 
+   * Once a stream has reached the end, subsequent calls to read or
+   * `skip` will always report end-of-stream rather than producing more
+   * data.
+   * 
+   * This function returns the number of bytes skipped, along with a
+   * `stream-status` indicating whether the end of the stream was
+   * reached. The returned value will be at most `len`; it may be less.
+   */
+  export function skip(this_: InputStream, len: bigint): [bigint, StreamStatus];
+  /**
+   * Skip bytes from a stream, after blocking until at least one byte
+   * can be skipped. Except for blocking behavior, identical to `skip`.
+   */
+  export function blockingSkip(this_: InputStream, len: bigint): [bigint, StreamStatus];
+  /**
+   * Create a `pollable` which will resolve once either the specified stream
+   * has bytes available to read or the other end of the stream has been
+   * closed.
+   * The created `pollable` is a child resource of the `input-stream`.
+   * Implementations may trap if the `input-stream` is dropped before
+   * all derived `pollable`s created with this function are dropped.
+   */
+  export function subscribeToInputStream(this_: InputStream): Pollable;
+  /**
+   * Dispose of the specified `input-stream`, after which it may no longer
+   * be used.
+   * Implementations may trap if this `input-stream` is dropped while child
+   * `pollable` resources are still alive.
+   * After this `input-stream` is dropped, implementations may report any
+   * corresponding `output-stream` has `stream-state.closed`.
+   */
+  export function dropInputStream(this_: InputStream): void;
+  /**
+   * Perform a non-blocking write of bytes to a stream.
+   * 
+   * This function returns a `u64` and a `stream-status`. The `u64` indicates
+   * the number of bytes from `buf` that were written, which may be less than
+   * the length of `buf`. The `stream-status` indicates if further writes to
+   * the stream are expected to be read.
+   * 
+   * When the returned `stream-status` is `open`, the `u64` return value may
+   * be less than the length of `buf`. This indicates that no more bytes may
+   * be written to the stream promptly. In that case the
+   * `subscribe-to-output-stream` pollable will indicate when additional bytes
+   * may be promptly written.
+   * 
+   * Writing an empty list must return a non-error result with `0` for the
+   * `u64` return value, and the current `stream-status`.
+   */
+  export function write(this_: OutputStream, buf: Uint8Array | ArrayBuffer): [bigint, StreamStatus];
+  /**
+   * Blocking write of bytes to a stream.
+   * 
+   * This is similar to `write`, except that it blocks until at least one
+   * byte can be written.
+   */
+  export function blockingWrite(this_: OutputStream, buf: Uint8Array | ArrayBuffer): [bigint, StreamStatus];
+  /**
+   * Write multiple zero-bytes to a stream.
+   * 
+   * This function returns a `u64` indicating the number of zero-bytes
+   * that were written; it may be less than `len`. Equivelant to a call to
+   * `write` with a list of zeroes of the given length.
+   */
+  export function writeZeroes(this_: OutputStream, len: bigint): [bigint, StreamStatus];
+  /**
+   * Write multiple zero bytes to a stream, with blocking.
+   * 
+   * This is similar to `write-zeroes`, except that it blocks until at least
+   * one byte can be written. Equivelant to a call to `blocking-write` with
+   * a list of zeroes of the given length.
+   */
+  export function blockingWriteZeroes(this_: OutputStream, len: bigint): [bigint, StreamStatus];
+  /**
+   * Read from one stream and write to another.
+   * 
+   * This function returns the number of bytes transferred; it may be less
+   * than `len`.
+   * 
+   * Unlike other I/O functions, this function blocks until all the data
+   * read from the input stream has been written to the output stream.
+   */
+  export function splice(this_: OutputStream, src: InputStream, len: bigint): [bigint, StreamStatus];
+  /**
+   * Read from one stream and write to another, with blocking.
+   * 
+   * This is similar to `splice`, except that it blocks until at least
+   * one byte can be read.
+   */
+  export function blockingSplice(this_: OutputStream, src: InputStream, len: bigint): [bigint, StreamStatus];
+  /**
+   * Forward the entire contents of an input stream to an output stream.
+   * 
+   * This function repeatedly reads from the input stream and writes
+   * the data to the output stream, until the end of the input stream
+   * is reached, or an error is encountered.
+   * 
+   * Unlike other I/O functions, this function blocks until the end
+   * of the input stream is seen and all the data has been written to
+   * the output stream.
+   * 
+   * This function returns the number of bytes transferred, and the status of
+   * the output stream.
+   */
+  export function forward(this_: OutputStream, src: InputStream): [bigint, StreamStatus];
+  /**
+   * Create a `pollable` which will resolve once either the specified stream
+   * is ready to accept bytes or the `stream-state` has become closed.
+   * 
+   * Once the stream-state is closed, this pollable is always ready
+   * immediately.
+   * 
+   * The created `pollable` is a child resource of the `output-stream`.
+   * Implementations may trap if the `output-stream` is dropped before
+   * all derived `pollable`s created with this function are dropped.
+   */
+  export function subscribeToOutputStream(this_: OutputStream): Pollable;
+  /**
+   * Dispose of the specified `output-stream`, after which it may no longer
+   * be used.
+   * Implementations may trap if this `output-stream` is dropped while
+   * child `pollable` resources are still alive.
+   * After this `output-stream` is dropped, implementations may report any
+   * corresponding `input-stream` has `stream-state.closed`.
+   */
+  export function dropOutputStream(this_: OutputStream): void;
+}
+import type { Pollable } from '../exports/wasi-poll-poll';
+export { Pollable };
+/**
+ * Streams provide a sequence of data and then end; once they end, they
+ * no longer provide any further data.
+ * 
+ * For example, a stream reading from a file ends when the stream reaches
+ * the end of the file. For another example, a stream reading from a
+ * socket ends when the socket is closed.
+ * # Variants
+ * 
+ * ## `"open"`
+ * 
+ * The stream is open and may produce further data.
+ * ## `"ended"`
+ * 
+ * When reading, this indicates that the stream will not produce
+ * further data.
+ * When writing, this indicates that the stream will no longer be read.
+ * Further writes are still permitted.
+ */
+export type StreamStatus = 'open' | 'ended';
+/**
+ * An input bytestream. In the future, this will be replaced by handle
+ * types.
+ * 
+ * `input-stream`s are *non-blocking* to the extent practical on underlying
+ * platforms. I/O operations always return promptly; if fewer bytes are
+ * promptly available than requested, they return the number of bytes promptly
+ * available, which could even be zero. To wait for data to be available,
+ * use the `subscribe-to-input-stream` function to obtain a `pollable` which
+ * can be polled for using `wasi:poll/poll.poll_oneoff`.
+ * 
+ * And at present, it is a `u32` instead of being an actual handle, until
+ * the wit-bindgen implementation of handles and resources is ready.
+ * 
+ * This [represents a resource](https://github.com/WebAssembly/WASI/blob/main/docs/WitInWasi.md#Resources).
+ */
+export type InputStream = number;
+/**
+ * An output bytestream. In the future, this will be replaced by handle
+ * types.
+ * 
+ * `output-stream`s are *non-blocking* to the extent practical on
+ * underlying platforms. Except where specified otherwise, I/O operations also
+ * always return promptly, after the number of bytes that can be written
+ * promptly, which could even be zero. To wait for the stream to be ready to
+ * accept data, the `subscribe-to-output-stream` function to obtain a
+ * `pollable` which can be polled for using `wasi:poll`.
+ * 
+ * And at present, it is a `u32` instead of being an actual handle, until
+ * the wit-bindgen implementation of handles and resources is ready.
+ * 
+ * This [represents a resource](https://github.com/WebAssembly/WASI/blob/main/docs/WitInWasi.md#Resources).
+ */
+export type OutputStream = number;

package/types/{imports/poll.d.ts → exports/wasi-poll-poll.d.ts}

@@ -1,9 +1,9 @@
-export namespace ImportsPoll {
+export namespace WasiPollPoll {
   /**
    * Dispose of the specified `pollable`, after which it may no longer
    * be used.
    */
-  export function dropPollable(this: Pollable): void;
+  export function dropPollable(this_: Pollable): void;
   /**
    * Poll for completion on a set of pollables.
    * 
@@ -14,13 +14,11 @@ export namespace ImportsPoll {
    * component model async proposal, which will include a scalable waiting
    * facility.
    * 
-   * Note that the return type would ideally be `list<bool>`, but that would
-   * be more difficult to polyfill given the current state of `wit-bindgen`.
-   * See <https://github.com/bytecodealliance/preview2-prototyping/pull/11#issuecomment-1329873061>
-   * for details.  For now, we use zero to mean "not ready" and non-zero to
-   * mean "ready".
+   * The result list<bool> is the same length as the argument
+   * list<pollable>, and indicates the readiness of each corresponding
+   * element in that / list, with true indicating ready.
    */
-  export function pollOneoff(in: Uint32Array): Uint8Array | ArrayBuffer;
+  export function pollOneoff(in_: Uint32Array): boolean[];
 }
 /**
  * A "pollable" handle.

package/types/{imports/insecure-seed.d.ts → exports/wasi-random-insecure-seed.d.ts}

@@ -1,4 +1,4 @@
-export namespace ImportsInsecureSeed {
+export namespace WasiRandomInsecureSeed {
   /**
    * Return a 128-bit value that may contain a pseudo-random value.
    * 

package/types/exports/wasi-random-insecure.d.ts

@@ -0,0 +1,20 @@
+export namespace WasiRandomInsecure {
+  /**
+   * Return `len` insecure pseudo-random bytes.
+   * 
+   * This function is not cryptographically secure. Do not use it for
+   * anything related to security.
+   * 
+   * There are no requirements on the values of the returned bytes, however
+   * implementations are encouraged to return evenly distributed values with
+   * a long period.
+   */
+  export function getInsecureRandomBytes(len: bigint): Uint8Array;
+  /**
+   * Return an insecure pseudo-random `u64` value.
+   * 
+   * This function returns the same type of pseudo-random data as
+   * `get-insecure-random-bytes`, represented as a `u64`.
+   */
+  export function getInsecureRandomU64(): bigint;
+}

package/types/exports/wasi-random-random.d.ts

@@ -0,0 +1,22 @@
+export namespace WasiRandomRandom {
+  /**
+   * Return `len` cryptographically-secure pseudo-random bytes.
+   * 
+   * This function must produce data from an adequately seeded
+   * cryptographically-secure pseudo-random number generator (CSPRNG), so it
+   * must not block, from the perspective of the calling program, and the
+   * returned data is always unpredictable.
+   * 
+   * This function must always return fresh pseudo-random data. Deterministic
+   * environments must omit this function, rather than implementing it with
+   * deterministic data.
+   */
+  export function getRandomBytes(len: bigint): Uint8Array;
+  /**
+   * Return a cryptographically-secure pseudo-random `u64` value.
+   * 
+   * This function returns the same type of pseudo-random data as
+   * `get-random-bytes`, represented as a `u64`.
+   */
+  export function getRandomU64(): bigint;
+}

package/types/{imports/instance-network.d.ts → exports/wasi-sockets-instance-network.d.ts}

@@ -1,8 +1,8 @@
-export namespace ImportsInstanceNetwork {
+export namespace WasiSocketsInstanceNetwork {
   /**
    * Get a handle to the default network.
    */
   export function instanceNetwork(): Network;
 }
-import type { Network } from '../imports/network';
+import type { Network } from '../exports/wasi-sockets-network';
 export { Network };

package/types/{imports/ip-name-lookup.d.ts → exports/wasi-sockets-ip-name-lookup.d.ts}

@@ -1,4 +1,4 @@
-export namespace ImportsIpNameLookup {
+export namespace WasiSocketsIpNameLookup {
   /**
    * Resolve an internet host name to a list of IP addresses.
    * 
@@ -48,29 +48,29 @@ export namespace ImportsIpNameLookup {
    * - `permanent-resolver-failure`: A permanent failure in name resolution occurred. (EAI_FAIL)
    * - `would-block`:                A result is not available yet. (EWOULDBLOCK, EAGAIN)
    */
-  export function resolveNextAddress(this: ResolveAddressStream): IpAddress | null;
+  export function resolveNextAddress(this_: ResolveAddressStream): IpAddress | null;
   /**
    * Dispose of the specified `resolve-address-stream`, after which it may no longer be used.
    * 
    * Note: this function is scheduled to be removed when Resources are natively supported in Wit.
    */
-  export function dropResolveAddressStream(this: ResolveAddressStream): void;
+  export function dropResolveAddressStream(this_: ResolveAddressStream): void;
   /**
    * Create a `pollable` which will resolve once the stream is ready for I/O.
    * 
    * Note: this function is here for WASI Preview2 only.
    * It's planned to be removed when `future` is natively supported in Preview3.
    */
-  export function subscribe(this: ResolveAddressStream): Pollable;
+  export function subscribe(this_: ResolveAddressStream): Pollable;
 }
-import type { Pollable } from '../imports/poll';
+import type { Pollable } from '../exports/wasi-poll-poll';
 export { Pollable };
-import type { Network } from '../imports/network';
+import type { Network } from '../exports/wasi-sockets-network';
 export { Network };
-import type { ErrorCode } from '../imports/network';
+import type { ErrorCode } from '../exports/wasi-sockets-network';
 export { ErrorCode };
-import type { IpAddress } from '../imports/network';
+import type { IpAddress } from '../exports/wasi-sockets-network';
 export { IpAddress };
-import type { IpAddressFamily } from '../imports/network';
+import type { IpAddressFamily } from '../exports/wasi-sockets-network';
 export { IpAddressFamily };
 export type ResolveAddressStream = number;