@ruby/head-wasm-wasi 2.6.1 → 2.6.2

package/dist/browser.script.iife.js

@@ -1438,7 +1438,9 @@ SOFTWARE.
                   const fs_filetypePtr = fdstat + 0;
                   view.setUint8(fs_filetypePtr, 2); // FILETYPE_CHARACTER_DEVICE
                   const fs_rights_basePtr = fdstat + 8;
-                  view.setBigUint64(fs_rights_basePtr, BigInt(1)); // RIGHTS_FD_WRITE
+                  // See https://github.com/WebAssembly/WASI/blob/v0.2.0/legacy/preview1/docs.md#record-members
+                  const RIGHTS_FD_WRITE = 1 << 6;
+                  view.setBigUint64(fs_rights_basePtr, BigInt(RIGHTS_FD_WRITE), true);
                   return 0;
               };
           },
@@ -2931,7 +2933,7 @@ SOFTWARE.
   };
 
   var name = "@ruby/head-wasm-wasi";
-  var version = "2.6.1";
+  var version = "2.6.2";
   var description = "Ruby head built on WASI";
   var main = "./dist/cjs/index.js";
   var module = "./dist/esm/index.js";

package/dist/browser.script.umd.js

@@ -150,7 +150,9 @@ Please replace your \`require('ruby-head-wasm-wasi/dist/browser.script.umd');\`
                     const fs_filetypePtr = fdstat + 0;
                     view.setUint8(fs_filetypePtr, 2); // FILETYPE_CHARACTER_DEVICE
                     const fs_rights_basePtr = fdstat + 8;
-                    view.setBigUint64(fs_rights_basePtr, BigInt(1)); // RIGHTS_FD_WRITE
+                    // See https://github.com/WebAssembly/WASI/blob/v0.2.0/legacy/preview1/docs.md#record-members
+                    const RIGHTS_FD_WRITE = 1 << 6;
+                    view.setBigUint64(fs_rights_basePtr, BigInt(RIGHTS_FD_WRITE), true);
                     return 0;
                 };
             },

package/dist/browser.umd.js

@@ -105,7 +105,9 @@
                     const fs_filetypePtr = fdstat + 0;
                     view.setUint8(fs_filetypePtr, 2); // FILETYPE_CHARACTER_DEVICE
                     const fs_rights_basePtr = fdstat + 8;
-                    view.setBigUint64(fs_rights_basePtr, BigInt(1)); // RIGHTS_FD_WRITE
+                    // See https://github.com/WebAssembly/WASI/blob/v0.2.0/legacy/preview1/docs.md#record-members
+                    const RIGHTS_FD_WRITE = 1 << 6;
+                    view.setBigUint64(fs_rights_basePtr, BigInt(RIGHTS_FD_WRITE), true);
                     return 0;
                 };
             },

package/dist/component/interfaces/wasi-cli-environment.d.ts

@@ -1,3 +1,5 @@
 export namespace WasiCliEnvironment {
   export function getEnvironment(): [string, string][];
+  export function getArguments(): string[];
+  export function initialCwd(): string | undefined;
 }

package/dist/component/interfaces/wasi-filesystem-types.d.ts

@@ -1,7 +1,6 @@
 export namespace WasiFilesystemTypes {
   export { Descriptor };
   export { DirectoryEntryStream };
-  export function filesystemErrorCode(err: Error): ErrorCode | undefined;
 }
 export type Filesize = bigint;
 import type { InputStream } from './wasi-io-streams.js';
@@ -84,32 +83,6 @@ export { InputStream };
  * ## `"cross-device"`
  */
 export type ErrorCode = 'access' | 'would-block' | 'already' | 'bad-descriptor' | 'busy' | 'deadlock' | 'quota' | 'exist' | 'file-too-large' | 'illegal-byte-sequence' | 'in-progress' | 'interrupted' | 'invalid' | 'io' | 'is-directory' | 'loop' | 'too-many-links' | 'message-size' | 'name-too-long' | 'no-device' | 'no-entry' | 'no-lock' | 'insufficient-memory' | 'insufficient-space' | 'not-directory' | 'not-empty' | 'not-recoverable' | 'unsupported' | 'no-tty' | 'no-such-device' | 'overflow' | 'not-permitted' | 'pipe' | 'read-only' | 'invalid-seek' | 'text-file-busy' | 'cross-device';
-import type { OutputStream } from './wasi-io-streams.js';
-export { OutputStream };
-/**
- * # Variants
- * 
- * ## `"normal"`
- * 
- * ## `"sequential"`
- * 
- * ## `"random"`
- * 
- * ## `"will-need"`
- * 
- * ## `"dont-need"`
- * 
- * ## `"no-reuse"`
- */
-export type Advice = 'normal' | 'sequential' | 'random' | 'will-need' | 'dont-need' | 'no-reuse';
-export interface DescriptorFlags {
-  read?: boolean,
-  write?: boolean,
-  fileIntegritySync?: boolean,
-  dataIntegritySync?: boolean,
-  requestedWriteSync?: boolean,
-  mutateDirectory?: boolean,
-}
 /**
  * # Variants
  * 
@@ -144,23 +117,20 @@ export interface DescriptorStat {
 export interface PathFlags {
   symlinkFollow?: boolean,
 }
-export type NewTimestamp = NewTimestampNoChange | NewTimestampNow | NewTimestampTimestamp;
-export interface NewTimestampNoChange {
-  tag: 'no-change',
-}
-export interface NewTimestampNow {
-  tag: 'now',
-}
-export interface NewTimestampTimestamp {
-  tag: 'timestamp',
-  val: Datetime,
-}
 export interface OpenFlags {
   create?: boolean,
   directory?: boolean,
   exclusive?: boolean,
   truncate?: boolean,
 }
+export interface DescriptorFlags {
+  read?: boolean,
+  write?: boolean,
+  fileIntegritySync?: boolean,
+  dataIntegritySync?: boolean,
+  requestedWriteSync?: boolean,
+  mutateDirectory?: boolean,
+}
 export interface MetadataHashValue {
   lower: bigint,
   upper: bigint,
@@ -169,33 +139,16 @@ export interface DirectoryEntry {
   type: DescriptorType,
   name: string,
 }
-import type { Error } from './wasi-io-streams.js';
-export { Error };
 
 export class Descriptor {
   readViaStream(offset: Filesize): InputStream;
-  writeViaStream(offset: Filesize): OutputStream;
-  appendViaStream(): OutputStream;
-  advise(offset: Filesize, length: Filesize, advice: Advice): void;
-  syncData(): void;
-  getFlags(): DescriptorFlags;
   getType(): DescriptorType;
-  setSize(size: Filesize): void;
-  read(length: Filesize, offset: Filesize): [Uint8Array, boolean];
-  write(buffer: Uint8Array, offset: Filesize): Filesize;
   readDirectory(): DirectoryEntryStream;
-  sync(): void;
-  createDirectoryAt(path: string): void;
   stat(): DescriptorStat;
   statAt(pathFlags: PathFlags, path: string): DescriptorStat;
-  setTimesAt(pathFlags: PathFlags, path: string, dataAccessTimestamp: NewTimestamp, dataModificationTimestamp: NewTimestamp): void;
-  linkAt(oldPathFlags: PathFlags, oldPath: string, newDescriptor: Descriptor, newPath: string): void;
   openAt(pathFlags: PathFlags, path: string, openFlags: OpenFlags, flags: DescriptorFlags): Descriptor;
   readlinkAt(path: string): string;
-  removeDirectoryAt(path: string): void;
-  renameAt(oldPath: string, newDescriptor: Descriptor, newPath: string): void;
-  symlinkAt(oldPath: string, newPath: string): void;
-  unlinkFileAt(path: string): void;
+  isSameObject(other: Descriptor): boolean;
   metadataHash(): MetadataHashValue;
   metadataHashAt(pathFlags: PathFlags, path: string): MetadataHashValue;
 }

package/dist/component/interfaces/wasi-http-outgoing-handler.d.ts

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

package/dist/component/interfaces/wasi-http-types.d.ts

@@ -0,0 +1,311 @@
+export namespace WasiHttpTypes {
+  export { Fields };
+  export { IncomingRequest };
+  export { OutgoingRequest };
+  export { RequestOptions };
+  export { ResponseOutparam };
+  export { IncomingResponse };
+  export { IncomingBody };
+  export { FutureTrailers };
+  export { OutgoingResponse };
+  export { OutgoingBody };
+  export { FutureIncomingResponse };
+  export function httpErrorCode(err: IoError): ErrorCode | undefined;
+}
+export type FieldKey = string;
+export type FieldValue = Uint8Array;
+export type HeaderError = HeaderErrorInvalidSyntax | HeaderErrorForbidden | HeaderErrorImmutable;
+export interface HeaderErrorInvalidSyntax {
+  tag: 'invalid-syntax',
+}
+export interface HeaderErrorForbidden {
+  tag: 'forbidden',
+}
+export interface HeaderErrorImmutable {
+  tag: 'immutable',
+}
+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;
+import type { Duration } from './wasi-clocks-monotonic-clock.js';
+export { Duration };
+export interface DnsErrorPayload {
+  rcode?: string,
+  infoCode?: number,
+}
+export interface TlsAlertReceivedPayload {
+  alertId?: number,
+  alertMessage?: string,
+}
+export interface FieldSizePayload {
+  fieldName?: string,
+  fieldSize?: number,
+}
+export type ErrorCode = ErrorCodeDnsTimeout | ErrorCodeDnsError | ErrorCodeDestinationNotFound | ErrorCodeDestinationUnavailable | ErrorCodeDestinationIpProhibited | ErrorCodeDestinationIpUnroutable | ErrorCodeConnectionRefused | ErrorCodeConnectionTerminated | ErrorCodeConnectionTimeout | ErrorCodeConnectionReadTimeout | ErrorCodeConnectionWriteTimeout | ErrorCodeConnectionLimitReached | ErrorCodeTlsProtocolError | ErrorCodeTlsCertificateError | ErrorCodeTlsAlertReceived | ErrorCodeHttpRequestDenied | ErrorCodeHttpRequestLengthRequired | ErrorCodeHttpRequestBodySize | ErrorCodeHttpRequestMethodInvalid | ErrorCodeHttpRequestUriInvalid | ErrorCodeHttpRequestUriTooLong | ErrorCodeHttpRequestHeaderSectionSize | ErrorCodeHttpRequestHeaderSize | ErrorCodeHttpRequestTrailerSectionSize | ErrorCodeHttpRequestTrailerSize | ErrorCodeHttpResponseIncomplete | ErrorCodeHttpResponseHeaderSectionSize | ErrorCodeHttpResponseHeaderSize | ErrorCodeHttpResponseBodySize | ErrorCodeHttpResponseTrailerSectionSize | ErrorCodeHttpResponseTrailerSize | ErrorCodeHttpResponseTransferCoding | ErrorCodeHttpResponseContentCoding | ErrorCodeHttpResponseTimeout | ErrorCodeHttpUpgradeFailed | ErrorCodeHttpProtocolError | ErrorCodeLoopDetected | ErrorCodeConfigurationError | ErrorCodeInternalError;
+export interface ErrorCodeDnsTimeout {
+  tag: 'DNS-timeout',
+}
+export interface ErrorCodeDnsError {
+  tag: 'DNS-error',
+  val: DnsErrorPayload,
+}
+export interface ErrorCodeDestinationNotFound {
+  tag: 'destination-not-found',
+}
+export interface ErrorCodeDestinationUnavailable {
+  tag: 'destination-unavailable',
+}
+export interface ErrorCodeDestinationIpProhibited {
+  tag: 'destination-IP-prohibited',
+}
+export interface ErrorCodeDestinationIpUnroutable {
+  tag: 'destination-IP-unroutable',
+}
+export interface ErrorCodeConnectionRefused {
+  tag: 'connection-refused',
+}
+export interface ErrorCodeConnectionTerminated {
+  tag: 'connection-terminated',
+}
+export interface ErrorCodeConnectionTimeout {
+  tag: 'connection-timeout',
+}
+export interface ErrorCodeConnectionReadTimeout {
+  tag: 'connection-read-timeout',
+}
+export interface ErrorCodeConnectionWriteTimeout {
+  tag: 'connection-write-timeout',
+}
+export interface ErrorCodeConnectionLimitReached {
+  tag: 'connection-limit-reached',
+}
+export interface ErrorCodeTlsProtocolError {
+  tag: 'TLS-protocol-error',
+}
+export interface ErrorCodeTlsCertificateError {
+  tag: 'TLS-certificate-error',
+}
+export interface ErrorCodeTlsAlertReceived {
+  tag: 'TLS-alert-received',
+  val: TlsAlertReceivedPayload,
+}
+export interface ErrorCodeHttpRequestDenied {
+  tag: 'HTTP-request-denied',
+}
+export interface ErrorCodeHttpRequestLengthRequired {
+  tag: 'HTTP-request-length-required',
+}
+export interface ErrorCodeHttpRequestBodySize {
+  tag: 'HTTP-request-body-size',
+  val: bigint | undefined,
+}
+export interface ErrorCodeHttpRequestMethodInvalid {
+  tag: 'HTTP-request-method-invalid',
+}
+export interface ErrorCodeHttpRequestUriInvalid {
+  tag: 'HTTP-request-URI-invalid',
+}
+export interface ErrorCodeHttpRequestUriTooLong {
+  tag: 'HTTP-request-URI-too-long',
+}
+export interface ErrorCodeHttpRequestHeaderSectionSize {
+  tag: 'HTTP-request-header-section-size',
+  val: number | undefined,
+}
+export interface ErrorCodeHttpRequestHeaderSize {
+  tag: 'HTTP-request-header-size',
+  val: FieldSizePayload | undefined,
+}
+export interface ErrorCodeHttpRequestTrailerSectionSize {
+  tag: 'HTTP-request-trailer-section-size',
+  val: number | undefined,
+}
+export interface ErrorCodeHttpRequestTrailerSize {
+  tag: 'HTTP-request-trailer-size',
+  val: FieldSizePayload,
+}
+export interface ErrorCodeHttpResponseIncomplete {
+  tag: 'HTTP-response-incomplete',
+}
+export interface ErrorCodeHttpResponseHeaderSectionSize {
+  tag: 'HTTP-response-header-section-size',
+  val: number | undefined,
+}
+export interface ErrorCodeHttpResponseHeaderSize {
+  tag: 'HTTP-response-header-size',
+  val: FieldSizePayload,
+}
+export interface ErrorCodeHttpResponseBodySize {
+  tag: 'HTTP-response-body-size',
+  val: bigint | undefined,
+}
+export interface ErrorCodeHttpResponseTrailerSectionSize {
+  tag: 'HTTP-response-trailer-section-size',
+  val: number | undefined,
+}
+export interface ErrorCodeHttpResponseTrailerSize {
+  tag: 'HTTP-response-trailer-size',
+  val: FieldSizePayload,
+}
+export interface ErrorCodeHttpResponseTransferCoding {
+  tag: 'HTTP-response-transfer-coding',
+  val: string | undefined,
+}
+export interface ErrorCodeHttpResponseContentCoding {
+  tag: 'HTTP-response-content-coding',
+  val: string | undefined,
+}
+export interface ErrorCodeHttpResponseTimeout {
+  tag: 'HTTP-response-timeout',
+}
+export interface ErrorCodeHttpUpgradeFailed {
+  tag: 'HTTP-upgrade-failed',
+}
+export interface ErrorCodeHttpProtocolError {
+  tag: 'HTTP-protocol-error',
+}
+export interface ErrorCodeLoopDetected {
+  tag: 'loop-detected',
+}
+export interface ErrorCodeConfigurationError {
+  tag: 'configuration-error',
+}
+export interface ErrorCodeInternalError {
+  tag: 'internal-error',
+  val: string | undefined,
+}
+export type StatusCode = number;
+import type { InputStream } from './wasi-io-streams.js';
+export { InputStream };
+import type { Pollable } from './wasi-io-poll.js';
+export { Pollable };
+export type Trailers = Fields;
+import type { OutputStream } from './wasi-io-streams.js';
+export { OutputStream };
+import type { Error as IoError } from './wasi-io-error.js';
+export { IoError };
+export type Result<T, E> = { tag: 'ok', val: T } | { tag: 'err', val: E };
+
+export class Fields {
+  constructor()
+  static fromList(entries: [FieldKey, FieldValue][]): Fields;
+  get(name: FieldKey): FieldValue[];
+  has(name: FieldKey): boolean;
+  set(name: FieldKey, value: FieldValue[]): void;
+  'delete'(name: FieldKey): void;
+  append(name: FieldKey, value: FieldValue): void;
+  entries(): [FieldKey, FieldValue][];
+  clone(): Fields;
+}
+
+export class FutureIncomingResponse {
+  subscribe(): Pollable;
+  get(): Result<Result<IncomingResponse, ErrorCode>, void> | undefined;
+}
+
+export class FutureTrailers {
+  subscribe(): Pollable;
+  get(): Result<Result<Trailers | undefined, ErrorCode>, void> | undefined;
+}
+
+export class IncomingBody {
+  stream(): InputStream;
+  static finish(this_: IncomingBody): FutureTrailers;
+}
+
+export class IncomingRequest {
+  method(): Method;
+  pathWithQuery(): string | undefined;
+  scheme(): Scheme | undefined;
+  authority(): string | undefined;
+  headers(): Headers;
+  consume(): IncomingBody;
+}
+
+export class IncomingResponse {
+  status(): StatusCode;
+  headers(): Headers;
+  consume(): IncomingBody;
+}
+
+export class OutgoingBody {
+  write(): OutputStream;
+  static finish(this_: OutgoingBody, trailers: Trailers | undefined): void;
+}
+
+export class OutgoingRequest {
+  constructor(headers: Headers)
+  body(): OutgoingBody;
+  method(): Method;
+  setMethod(method: Method): void;
+  pathWithQuery(): string | undefined;
+  setPathWithQuery(pathWithQuery: string | undefined): void;
+  scheme(): Scheme | undefined;
+  setScheme(scheme: Scheme | undefined): void;
+  authority(): string | undefined;
+  setAuthority(authority: string | undefined): void;
+  headers(): Headers;
+}
+
+export class OutgoingResponse {
+  constructor(headers: Headers)
+  statusCode(): StatusCode;
+  setStatusCode(statusCode: StatusCode): void;
+  headers(): Headers;
+  body(): OutgoingBody;
+}
+
+export class RequestOptions {
+  constructor()
+  connectTimeout(): Duration | undefined;
+  setConnectTimeout(duration: Duration | undefined): void;
+  firstByteTimeout(): Duration | undefined;
+  setFirstByteTimeout(duration: Duration | undefined): void;
+  betweenBytesTimeout(): Duration | undefined;
+  setBetweenBytesTimeout(duration: Duration | undefined): void;
+}
+
+export class ResponseOutparam {
+  static set(param: ResponseOutparam, response: Result<OutgoingResponse, ErrorCode>): void;
+}

package/dist/component/interfaces/wasi-io-poll.d.ts

@@ -1,7 +1,9 @@
 export namespace WasiIoPoll {
-  export function poll(in_: Pollable[]): Uint32Array;
   export { Pollable };
+  export function poll(in_: Pollable[]): Uint32Array;
 }
 
 export class Pollable {
+  ready(): boolean;
+  block(): void;
 }

package/dist/component/interfaces/wasi-io-streams.d.ts

@@ -18,6 +18,8 @@ export { Pollable };
 export class InputStream {
   read(len: bigint): Uint8Array;
   blockingRead(len: bigint): Uint8Array;
+  skip(len: bigint): bigint;
+  blockingSkip(len: bigint): bigint;
   subscribe(): Pollable;
 }
 
@@ -25,6 +27,11 @@ export class OutputStream {
   checkWrite(): bigint;
   write(contents: Uint8Array): void;
   blockingWriteAndFlush(contents: Uint8Array): void;
+  flush(): void;
   blockingFlush(): void;
   subscribe(): Pollable;
+  writeZeroes(len: bigint): void;
+  blockingWriteZeroesAndFlush(len: bigint): void;
+  splice(src: InputStream, len: bigint): bigint;
+  blockingSplice(src: InputStream, len: bigint): bigint;
 }