@bytecodealliance/preview2-shim 0.0.3 → 0.0.4

package/types/imports/types.d.ts

@@ -0,0 +1,119 @@
+export namespace Types {
+  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 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 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 incomingRequestScheme(request: IncomingRequest): Scheme | null;
+  export function incomingRequestAuthority(request: IncomingRequest): string;
+  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 outgoingRequestWrite(request: OutgoingRequest): OutgoingStream;
+  export function dropResponseOutparam(response: ResponseOutparam): void;
+  export function setResponseOutparam(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;
+}
+export type Fields = number;
+import type { InputStream } from '../imports/streams';
+export { InputStream };
+export type IncomingStream = InputStream;
+export type Trailers = Fields;
+import type { OutputStream } from '../imports/streams';
+export { OutputStream };
+export type OutgoingStream = OutputStream;
+export type IncomingRequest = number;
+export type OutgoingRequest = number;
+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 Headers = Fields;
+export type ResponseOutparam = number;
+export type OutgoingResponse = number;
+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 IncomingResponse = number;
+export type StatusCode = number;
+export type FutureIncomingResponse = number;
+import type { Pollable } from '../imports/poll';
+export { Pollable };
+export interface RequestOptions {
+  connectTimeoutMs?: number,
+  firstByteTimeoutMs?: number,
+  betweenBytesTimeoutMs?: number,
+}
+export type Result<T, E> = { tag: 'ok', val: T } | { tag: 'err', val: E };

package/types/imports/udp-create-socket.d.ts

@@ -0,0 +1,9 @@
+export namespace UdpCreateSocket {
+  export function createUdpSocket(addressFamily: IpAddressFamily): UdpSocket;
+}
+import type { IpAddressFamily } from '../imports/network';
+export { IpAddressFamily };
+import type { UdpSocket } from '../imports/udp';
+export { UdpSocket };
+import type { Error } from '../imports/network';
+export { Error };

package/types/imports/udp.d.ts

@@ -0,0 +1,36 @@
+export namespace Udp {
+  export function bind(this: UdpSocket, network: Network, localAddress: IpSocketAddress): void;
+  export function connect(this: UdpSocket, network: Network, remoteAddress: IpSocketAddress): void;
+  export function receive(this: UdpSocket): Datagram;
+  export function send(this: UdpSocket, datagram: Datagram): void;
+  export function localAddress(this: UdpSocket): IpSocketAddress;
+  export function remoteAddress(this: UdpSocket): IpSocketAddress;
+  export function addressFamily(this: UdpSocket): IpAddressFamily;
+  export function ipv6Only(this: UdpSocket): boolean;
+  export function setIpv6Only(this: UdpSocket, value: boolean): void;
+  export function unicastHopLimit(this: UdpSocket): number;
+  export function setUnicastHopLimit(this: UdpSocket, value: number): void;
+  export function receiveBufferSize(this: UdpSocket): bigint;
+  export function setReceiveBufferSize(this: UdpSocket, value: bigint): void;
+  export function sendBufferSize(this: UdpSocket): bigint;
+  export function setSendBufferSize(this: UdpSocket, value: bigint): void;
+  export function nonBlocking(this: UdpSocket): boolean;
+  export function setNonBlocking(this: UdpSocket, value: boolean): void;
+  export function subscribe(this: UdpSocket): Pollable;
+  export function dropUdpSocket(this: UdpSocket): void;
+}
+export type UdpSocket = number;
+import type { Network } from '../imports/network';
+export { Network };
+import type { IpSocketAddress } from '../imports/network';
+export { IpSocketAddress };
+import type { Error } from '../imports/network';
+export { Error };
+export interface Datagram {
+  data: Uint8Array,
+  remoteAddress: IpSocketAddress,
+}
+import type { IpAddressFamily } from '../imports/network';
+export { IpAddressFamily };
+import type { Pollable } from '../imports/poll';
+export { Pollable };

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

@@ -0,0 +1,10 @@
+export namespace WallClock {
+  export function now(this: WallClock): Datetime;
+  export function resolution(this: WallClock): Datetime;
+  export function dropWallClock(this: WallClock): void;
+}
+export type WallClock = number;
+export interface Datetime {
+  seconds: bigint,
+  nanoseconds: number,
+}

package/types/index.d.ts

@@ -1,9 +1,8 @@
-export * as clocks from "./types/wasi-clocks";
-export * as defaultClocks from "./types/wasi-default-clocks";
-export * as exit from "./types/wasi-exit";
-export * as filesystem from "./types/wasi-filesystem";
-export * as io from "./types/wasi-io";
-export * as logging from "./types/wasi-logging";
-export * as poll from "./types/wasi-poll";
-export * as random from "./types/wasi-random";
-export * as stderr from "./types/wasi-stderr";
+import { ImportObject as WasiProxyImportObject } from "./wasi-proxy";
+import { ImportObject as WasiReactorImportObject } from "./wasi-reactor";
+
+export type ImportObject = WasiProxyImportObject & WasiReactorImportObject;
+
+export declare const importObject: ImportObject;
+
+export default importObject;

package/types/wasi-proxy.d.ts

@@ -0,0 +1,44 @@
+import { Random as RandomImports } from './imports/random';
+import { Console as ConsoleImports } from './imports/console';
+import { Poll as PollImports } from './imports/poll';
+import { Streams as StreamsImports } from './imports/streams';
+import { Types as TypesImports } from './imports/types';
+import { DefaultOutgoingHttp as DefaultOutgoingHttpImports } from './imports/default-outgoing-HTTP';
+import { Http as HttpExports } from './exports/HTTP';
+export interface ImportObject {
+  'random': typeof RandomImports,
+  'console': typeof ConsoleImports,
+  'poll': typeof PollImports,
+  'streams': typeof StreamsImports,
+  'types': typeof TypesImports,
+  'default-outgoing-HTTP': typeof DefaultOutgoingHttpImports,
+}
+export interface WasiProxy {
+  'HTTP': typeof HttpExports,
+}
+
+/**
+* Instantiates this component with the provided imports and
+* returns a map of all the exports of the component.
+*
+* This function is intended to be similar to the
+* `WebAssembly.instantiate` function. The second `imports`
+* argument is the "import object" for wasm, except here it
+* uses component-model-layer types instead of core wasm
+* integers/numbers/etc.
+*
+* The first argument to this function, `compileCore`, is
+* used to compile core wasm modules within the component.
+* Components are composed of core wasm modules and this callback
+* will be invoked per core wasm module. The caller of this
+* function is responsible for reading the core wasm module
+* identified by `path` and returning its compiled
+* WebAssembly.Module object. This would use `compileStreaming`
+* on the web, for example.
+*/
+export function instantiate(
+compileCore: (path: string, imports: Record<string, any>) => Promise<WebAssembly.Module>,
+imports: ImportObject,
+instantiateCore?: (module: WebAssembly.Module, imports: Record<string, any>) => Promise<WebAssembly.Instance>
+): Promise<WasiProxy>;
+

package/types/wasi-reactor.d.ts

@@ -0,0 +1,70 @@
+import { WallClock as WallClockImports } from './imports/wall-clock';
+import { Poll as PollImports } from './imports/poll';
+import { MonotonicClock as MonotonicClockImports } from './imports/monotonic-clock';
+import { InstanceWallClock as InstanceWallClockImports } from './imports/instance-wall-clock';
+import { InstanceMonotonicClock as InstanceMonotonicClockImports } from './imports/instance-monotonic-clock';
+import { Timezone as TimezoneImports } from './imports/timezone';
+import { Streams as StreamsImports } from './imports/streams';
+import { Filesystem as FilesystemImports } from './imports/filesystem';
+import { Network as NetworkImports } from './imports/network';
+import { InstanceNetwork as InstanceNetworkImports } from './imports/instance-network';
+import { IpNameLookup as IpNameLookupImports } from './imports/ip-name-lookup';
+import { Tcp as TcpImports } from './imports/tcp';
+import { TcpCreateSocket as TcpCreateSocketImports } from './imports/tcp-create-socket';
+import { Udp as UdpImports } from './imports/udp';
+import { UdpCreateSocket as UdpCreateSocketImports } from './imports/udp-create-socket';
+import { Random as RandomImports } from './imports/random';
+import { Environment as EnvironmentImports } from './imports/environment';
+import { EnvironmentPreopens as EnvironmentPreopensImports } from './imports/environment-preopens';
+import { Exit as ExitImports } from './imports/exit';
+import { Stderr as StderrImports } from './imports/stderr';
+export interface ImportObject {
+  'wall-clock': typeof WallClockImports,
+  'poll': typeof PollImports,
+  'monotonic-clock': typeof MonotonicClockImports,
+  'instance-wall-clock': typeof InstanceWallClockImports,
+  'instance-monotonic-clock': typeof InstanceMonotonicClockImports,
+  'timezone': typeof TimezoneImports,
+  'streams': typeof StreamsImports,
+  'filesystem': typeof FilesystemImports,
+  'network': typeof NetworkImports,
+  'instance-network': typeof InstanceNetworkImports,
+  'ip-name-lookup': typeof IpNameLookupImports,
+  'tcp': typeof TcpImports,
+  'tcp-create-socket': typeof TcpCreateSocketImports,
+  'udp': typeof UdpImports,
+  'udp-create-socket': typeof UdpCreateSocketImports,
+  'random': typeof RandomImports,
+  'environment': typeof EnvironmentImports,
+  'environment-preopens': typeof EnvironmentPreopensImports,
+  'exit': typeof ExitImports,
+  'stderr': typeof StderrImports,
+}
+export interface WasiReactor {
+}
+
+/**
+* Instantiates this component with the provided imports and
+* returns a map of all the exports of the component.
+*
+* This function is intended to be similar to the
+* `WebAssembly.instantiate` function. The second `imports`
+* argument is the "import object" for wasm, except here it
+* uses component-model-layer types instead of core wasm
+* integers/numbers/etc.
+*
+* The first argument to this function, `compileCore`, is
+* used to compile core wasm modules within the component.
+* Components are composed of core wasm modules and this callback
+* will be invoked per core wasm module. The caller of this
+* function is responsible for reading the core wasm module
+* identified by `path` and returning its compiled
+* WebAssembly.Module object. This would use `compileStreaming`
+* on the web, for example.
+*/
+export function instantiate(
+compileCore: (path: string, imports: Record<string, any>) => Promise<WebAssembly.Module>,
+imports: ImportObject,
+instantiateCore?: (module: WebAssembly.Module, imports: Record<string, any>) => Promise<WebAssembly.Instance>
+): Promise<WasiReactor>;
+

package/types/wasi-clocks.d.ts

@@ -1,11 +0,0 @@
-export type MonotonicClock = number;
-export type Instant = bigint;
-export type WallClock = number;
-export interface Datetime {
-  seconds: bigint,
-  nanoseconds: number,
-}
-export namespace WasiClocks {
-  export function monotonicClockNow(clock: MonotonicClock): Instant;
-  export function wallClockNow(clock: WallClock): Datetime;
-}

package/types/wasi-default-clocks.d.ts

@@ -1,6 +0,0 @@
-export type MonotonicClock = MonotonicClock;
-export type WallClock = WallClock;
-export namespace WasiDefaultClocks {
-  export function defaultMonotonicClock(): MonotonicClock;
-  export function defaultWallClock(): WallClock;
-}

package/types/wasi-exit.d.ts

@@ -1,3 +0,0 @@
-export namespace WasiExit {
-  export function exit(status: { tag: 'err' | 'ok' }): void;
-}

package/types/wasi-filesystem.d.ts

@@ -1,150 +0,0 @@
-export type Descriptor = number;
-export type Filesize = bigint;
-export type InputStream = InputStream;
-/**
- * # Variants
- * 
- * ## `"access"`
- * 
- * ## `"again"`
- * 
- * ## `"already"`
- * 
- * ## `"badf"`
- * 
- * ## `"busy"`
- * 
- * ## `"deadlk"`
- * 
- * ## `"dquot"`
- * 
- * ## `"exist"`
- * 
- * ## `"fbig"`
- * 
- * ## `"ilseq"`
- * 
- * ## `"inprogress"`
- * 
- * ## `"intr"`
- * 
- * ## `"inval"`
- * 
- * ## `"io"`
- * 
- * ## `"isdir"`
- * 
- * ## `"loop"`
- * 
- * ## `"mlink"`
- * 
- * ## `"msgsize"`
- * 
- * ## `"nametoolong"`
- * 
- * ## `"nodev"`
- * 
- * ## `"noent"`
- * 
- * ## `"nolck"`
- * 
- * ## `"nomem"`
- * 
- * ## `"nospc"`
- * 
- * ## `"nosys"`
- * 
- * ## `"notdir"`
- * 
- * ## `"notempty"`
- * 
- * ## `"notrecoverable"`
- * 
- * ## `"notsup"`
- * 
- * ## `"notty"`
- * 
- * ## `"nxio"`
- * 
- * ## `"overflow"`
- * 
- * ## `"perm"`
- * 
- * ## `"pipe"`
- * 
- * ## `"rofs"`
- * 
- * ## `"spipe"`
- * 
- * ## `"txtbsy"`
- * 
- * ## `"xdev"`
- */
-export type Errno = 'access' | 'again' | 'already' | 'badf' | 'busy' | 'deadlk' | 'dquot' | 'exist' | 'fbig' | 'ilseq' | 'inprogress' | 'intr' | 'inval' | 'io' | 'isdir' | 'loop' | 'mlink' | 'msgsize' | 'nametoolong' | 'nodev' | 'noent' | 'nolck' | 'nomem' | 'nospc' | 'nosys' | 'notdir' | 'notempty' | 'notrecoverable' | 'notsup' | 'notty' | 'nxio' | 'overflow' | 'perm' | 'pipe' | 'rofs' | 'spipe' | 'txtbsy' | 'xdev';
-export type OutputStream = OutputStream;
-export type DirEntryStream = number;
-export type Device = bigint;
-export type Inode = bigint;
-/**
- * # Variants
- * 
- * ## `"unknown"`
- * 
- * ## `"block-device"`
- * 
- * ## `"character-device"`
- * 
- * ## `"directory"`
- * 
- * ## `"fifo"`
- * 
- * ## `"symbolic-link"`
- * 
- * ## `"regular-file"`
- * 
- * ## `"socket"`
- */
-export type DescriptorType = 'unknown' | 'block-device' | 'character-device' | 'directory' | 'fifo' | 'symbolic-link' | 'regular-file' | 'socket';
-export type Linkcount = bigint;
-export type Datetime = Datetime;
-export interface DescriptorStat {
-  dev: Device,
-  ino: Inode,
-  type: DescriptorType,
-  nlink: Linkcount,
-  size: Filesize,
-  atim: Datetime,
-  mtim: Datetime,
-  ctim: Datetime,
-}
-export interface AtFlags {
-  symlinkFollow?: boolean,
-}
-export interface OFlags {
-  create?: boolean,
-  directory?: boolean,
-  excl?: boolean,
-  trunc?: boolean,
-}
-export interface DescriptorFlags {
-  read?: boolean,
-  write?: boolean,
-  dsync?: boolean,
-  nonblock?: boolean,
-  rsync?: boolean,
-  sync?: boolean,
-}
-export interface Mode {
-  readable?: boolean,
-  writeable?: boolean,
-  executable?: boolean,
-}
-export namespace WasiFilesystem {
-  export function readViaStream(fd: Descriptor, offset: Filesize): InputStream;
-  export function writeViaStream(fd: Descriptor, offset: Filesize): OutputStream;
-  export function appendViaStream(fd: Descriptor): OutputStream;
-  export function closeDirEntryStream(s: DirEntryStream): void;
-  export function stat(fd: Descriptor): DescriptorStat;
-  export function openAt(fd: Descriptor, atFlags: AtFlags, path: string, oFlags: OFlags, flags: DescriptorFlags, mode: Mode): Descriptor;
-  export function close(fd: Descriptor): void;
-}

package/types/wasi-http.d.ts

@@ -1,55 +0,0 @@
-/**
- * # Variants
- * 
- * ## `"get"`
- * 
- * ## `"post"`
- * 
- * ## `"put"`
- * 
- * ## `"delete"`
- * 
- * ## `"patch"`
- * 
- * ## `"head"`
- * 
- * ## `"options"`
- */
-export type Method = 'get' | 'post' | 'put' | 'delete' | 'patch' | 'head' | 'options';
-export type Uri = string;
-export type Headers = [string, string][];
-export type Params = [string, string][];
-export type Body = Uint8Array;
-export interface Request {
-  method: Method,
-  uri: Uri,
-  headers: Headers,
-  params: Params,
-  body?: Body,
-}
-export type HttpStatus = number;
-export interface Response {
-  status: HttpStatus,
-  headers?: Headers,
-  body?: Body,
-}
-export type HttpError = HttpErrorInvalidUrl | HttpErrorTimeoutError | HttpErrorProtocolError | HttpErrorUnexpectedError;
-export interface HttpErrorInvalidUrl {
-  tag: 'invalid-url',
-  val: string,
-}
-export interface HttpErrorTimeoutError {
-  tag: 'timeout-error',
-  val: string,
-}
-export interface HttpErrorProtocolError {
-  tag: 'protocol-error',
-  val: string,
-}
-export interface HttpErrorUnexpectedError {
-  tag: 'unexpected-error',
-  val: string,
-}
-export namespace WasiHttp {
-  export function send(req: Request): Response;
-}

package/types/wasi-io.d.ts

@@ -1,10 +0,0 @@
-export type InputStream = number;
-export interface StreamError {
-}
-export type OutputStream = number;
-export namespace WasiIo {
-  export function read(src: InputStream, len: bigint): [Uint8Array | ArrayBuffer, boolean];
-  export function write(dst: OutputStream, buf: Uint8Array): bigint;
-  export function dropInputStream(f: InputStream): void;
-  export function dropOutputStream(f: OutputStream): void;
-}

package/types/wasi-poll.d.ts

@@ -1,4 +0,0 @@
-export type Pollable = number;
-export namespace WasiPoll {
-  export function pollOneoff(input: Pollable[]): Uint8Array;
-}

package/types/wasi-random.d.ts

@@ -1,3 +0,0 @@
-export namespace WasiRandom {
-  export function getRandomBytes(len: number): Uint8Array | ArrayBuffer;
-}