@bytecodealliance/preview2-shim 0.0.14 → 0.0.16

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

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

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

@@ -1,9 +0,0 @@
-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/exports/wasi-http-types.d.ts

@@ -1,118 +0,0 @@
-export namespace WasiHttpTypes {
-  export function dropFields(fields: Fields): void;
-  export function newFields(entries: [string, string][]): Fields;
-  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: 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 incomingRequestPathWithQuery(request: IncomingRequest): string | null;
-  export function incomingRequestScheme(request: IncomingRequest): Scheme | null;
-  export function incomingRequestAuthority(request: IncomingRequest): string | null;
-  export function incomingRequestHeaders(request: IncomingRequest): Headers;
-  export function incomingRequestConsume(request: IncomingRequest): IncomingStream;
-  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(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;
-  export function incomingResponseHeaders(response: IncomingResponse): Headers;
-  export function incomingResponseConsume(response: IncomingResponse): IncomingStream;
-  export function newOutgoingResponse(statusCode: StatusCode, headers: Headers): OutgoingResponse;
-  export function outgoingResponseWrite(response: OutgoingResponse): OutgoingStream;
-  export function dropFutureIncomingResponse(f: FutureIncomingResponse): void;
-  export function futureIncomingResponseGet(f: FutureIncomingResponse): Result<IncomingResponse, Error> | null;
-  export function listenToFutureIncomingResponse(f: FutureIncomingResponse): Pollable;
-}
-import type { InputStream } from '../exports/wasi-io-streams';
-export { InputStream };
-import type { OutputStream } from '../exports/wasi-io-streams';
-export { OutputStream };
-import type { Pollable } from '../exports/wasi-poll-poll';
-export { Pollable };
-export type Method = MethodGet | MethodHead | MethodPost | MethodPut | MethodDelete | MethodConnect | MethodOptions | MethodTrace | MethodPatch | MethodOther;
-export interface MethodGet {
-  tag: 'get',
-}
-export interface MethodHead {
-  tag: 'head',
-}
-export interface MethodPost {
-  tag: 'post',
-}
-export interface MethodPut {
-  tag: 'put',
-}
-export interface MethodDelete {
-  tag: 'delete',
-}
-export interface MethodConnect {
-  tag: 'connect',
-}
-export interface MethodOptions {
-  tag: 'options',
-}
-export interface MethodTrace {
-  tag: 'trace',
-}
-export interface MethodPatch {
-  tag: 'patch',
-}
-export interface MethodOther {
-  tag: 'other',
-  val: string,
-}
-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',
-  val: string,
-}
-export interface ErrorTimeoutError {
-  tag: 'timeout-error',
-  val: string,
-}
-export interface ErrorProtocolError {
-  tag: 'protocol-error',
-  val: string,
-}
-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

@@ -1,220 +0,0 @@
-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/exports/wasi-sockets-instance-network.d.ts

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

package/types/exports/wasi-sockets-tcp-create-socket.d.ts

@@ -1,33 +0,0 @@
-export namespace WasiSocketsTcpCreateSocket {
-  /**
-   * Create a new TCP socket.
-   * 
-   * Similar to `socket(AF_INET or AF_INET6, SOCK_STREAM, IPPROTO_TCP)` in POSIX.
-   * 
-   * This function does not require a network capability handle. This is considered to be safe because
-   * at time of creation, the socket is not bound to any `network` yet. Up to the moment `bind`/`listen`/`connect`
-   * is called, the socket is effectively an in-memory configuration object, unable to communicate with the outside world.
-   * 
-   * All sockets are non-blocking. Use the wasi-poll interface to block on asynchronous operations.
-   * 
-   * # Typical errors
-   * - `not-supported`:                The host does not support TCP sockets. (EOPNOTSUPP)
-   * - `address-family-not-supported`: The specified `address-family` is not supported. (EAFNOSUPPORT)
-   * - `new-socket-limit`:             The new socket resource could not be created because of a system limit. (EMFILE, ENFILE)
-   * 
-   * # References
-   * - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/socket.html>
-   * - <https://man7.org/linux/man-pages/man2/socket.2.html>
-   * - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsasocketw>
-   * - <https://man.freebsd.org/cgi/man.cgi?query=socket&sektion=2>
-   */
-  export function createTcpSocket(addressFamily: IpAddressFamily): TcpSocket;
-}
-import type { Network } from '../exports/wasi-sockets-network';
-export { Network };
-import type { ErrorCode } from '../exports/wasi-sockets-network';
-export { ErrorCode };
-import type { IpAddressFamily } from '../exports/wasi-sockets-network';
-export { IpAddressFamily };
-import type { TcpSocket } from '../exports/wasi-sockets-tcp';
-export { TcpSocket };