@ruby/wasm-wasi 0.0.0-next

package/README.md

@@ -0,0 +1,7 @@
+# @ruby/wasm-wasi
+
+This package is a template for each channel-specific package.
+
+| Channel | Package                                           |
+| ------- | ------------------------------------------------- |
+| `head`  | [`ruby-head-wasm-wasi`](./../ruby-head-wasm-wasi) |

package/dist/bindgen/rb-abi-guest.d.ts

@@ -0,0 +1,140 @@
+export type RbErrno = number;
+export type RbId = number;
+export class RbAbiGuest {
+  
+  /**
+  * The WebAssembly instance that this class is operating with.
+  * This is only available after the `instantiate` method has
+  * been called.
+  */
+  instance: WebAssembly.Instance;
+  
+  /**
+  * Constructs a new instance with internal state necessary to
+  * manage a wasm instance.
+  *
+  * Note that this does not actually instantiate the WebAssembly
+  * instance or module, you'll need to call the `instantiate`
+  * method below to "activate" this class.
+  */
+  constructor();
+  
+  /**
+  * This is a low-level method which can be used to add any
+  * intrinsics necessary for this instance to operate to an
+  * import object.
+  *
+  * The `import` object given here is expected to be used later
+  * to actually instantiate the module this class corresponds to.
+  * If the `instantiate` method below actually does the
+  * instantiation then there's no need to call this method, but
+  * if you're instantiating manually elsewhere then this can be
+  * used to prepare the import object for external instantiation.
+  */
+  addToImports(imports: any): void;
+  
+  /**
+  * Initializes this object with the provided WebAssembly
+  * module/instance.
+  *
+  * This is intended to be a flexible method of instantiating
+  * and completion of the initialization of this class. This
+  * method must be called before interacting with the
+  * WebAssembly object.
+  *
+  * The first argument to this method is where to get the
+  * wasm from. This can be a whole bunch of different types,
+  * for example:
+  *
+  * * A precompiled `WebAssembly.Module`
+  * * A typed array buffer containing the wasm bytecode.
+  * * A `Promise` of a `Response` which is used with
+  *   `instantiateStreaming`
+  * * A `Response` itself used with `instantiateStreaming`.
+  * * An already instantiated `WebAssembly.Instance`
+  *
+  * If necessary the module is compiled, and if necessary the
+  * module is instantiated. Whether or not it's necessary
+  * depends on the type of argument provided to
+  * instantiation.
+  *
+  * If instantiation is performed then the `imports` object
+  * passed here is the list of imports used to instantiate
+  * the instance. This method may add its own intrinsics to
+  * this `imports` object too.
+  */
+  instantiate(
+  module: WebAssembly.Module | BufferSource | Promise<Response> | Response | WebAssembly.Instance,
+  imports?: any,
+  ): Promise<void>;
+  rubyShowVersion(): void;
+  rubyInit(): void;
+  rubySysinit(args: string[]): void;
+  rubyOptions(args: string[]): RbIseq;
+  rubyScript(name: string): void;
+  rubyInitLoadpath(): void;
+  rbEvalStringProtect(str: string): [RbAbiValue, number];
+  rbFuncallvProtect(recv: RbAbiValue, mid: RbId, args: RbAbiValue[]): [RbAbiValue, number];
+  rbIntern(name: string): RbId;
+  rbErrinfo(): RbAbiValue;
+  rbClearErrinfo(): void;
+  rstringPtr(value: RbAbiValue): string;
+  rbVmBugreport(): void;
+  rbGcEnable(): boolean;
+  rbGcDisable(): boolean;
+  rbSetShouldProhibitRewind(newValue: boolean): boolean;
+}
+
+export class RbIseq {
+  // Creates a new strong reference count as a new
+  // object.  This is only required if you're also
+  // calling `drop` below and want to manually manage
+  // the reference count from JS.
+  //
+  // If you don't call `drop`, you don't need to call
+  // this and can simply use the object from JS.
+  clone(): RbIseq;
+  
+  // Explicitly indicate that this JS object will no
+  // longer be used. If the internal reference count
+  // reaches zero then this will deterministically
+  // destroy the underlying wasm object.
+  //
+  // This is not required to be called from JS. Wasm
+  // destructors will be automatically called for you
+  // if this is not called using the JS
+  // `FinalizationRegistry`.
+  //
+  // Calling this method does not guarantee that the
+  // underlying wasm object is deallocated. Something
+  // else (including wasm) may be holding onto a
+  // strong reference count.
+  drop(): void;
+}
+
+export class RbAbiValue {
+  // Creates a new strong reference count as a new
+  // object.  This is only required if you're also
+  // calling `drop` below and want to manually manage
+  // the reference count from JS.
+  //
+  // If you don't call `drop`, you don't need to call
+  // this and can simply use the object from JS.
+  clone(): RbAbiValue;
+  
+  // Explicitly indicate that this JS object will no
+  // longer be used. If the internal reference count
+  // reaches zero then this will deterministically
+  // destroy the underlying wasm object.
+  //
+  // This is not required to be called from JS. Wasm
+  // destructors will be automatically called for you
+  // if this is not called using the JS
+  // `FinalizationRegistry`.
+  //
+  // Calling this method does not guarantee that the
+  // underlying wasm object is deallocated. Something
+  // else (including wasm) may be holding onto a
+  // strong reference count.
+  drop(): void;
+}

package/dist/bindgen/rb-js-abi-host.d.ts

@@ -0,0 +1,53 @@
+export type JsAbiResult = JsAbiResultSuccess | JsAbiResultFailure;
+export interface JsAbiResultSuccess {
+  tag: "success",
+  val: JsAbiValue,
+}
+export interface JsAbiResultFailure {
+  tag: "failure",
+  val: JsAbiValue,
+}
+export type RawInteger = RawIntegerF64 | RawIntegerBignum;
+export interface RawIntegerF64 {
+  tag: "f64",
+  val: number,
+}
+export interface RawIntegerBignum {
+  tag: "bignum",
+  val: string,
+}
+export function addRbJsAbiHostToImports(imports: any, obj: RbJsAbiHost, get_export: (name: string) => WebAssembly.ExportValue): void;
+export interface RbJsAbiHost {
+  evalJs(code: string): JsAbiResult;
+  isJs(value: JsAbiValue): boolean;
+  instanceOf(value: JsAbiValue, klass: JsAbiValue): boolean;
+  globalThis(): JsAbiValue;
+  intToJsNumber(value: number): JsAbiValue;
+  floatToJsNumber(value: number): JsAbiValue;
+  stringToJsString(value: string): JsAbiValue;
+  boolToJsBool(value: boolean): JsAbiValue;
+  procToJsFunction(value: number): JsAbiValue;
+  rbObjectToJsRbValue(rawRbAbiValue: number): JsAbiValue;
+  jsValueToString(value: JsAbiValue): string;
+  jsValueToInteger(value: JsAbiValue): RawInteger;
+  exportJsValueToHost(value: JsAbiValue): void;
+  importJsValueFromHost(): JsAbiValue;
+  jsValueTypeof(value: JsAbiValue): string;
+  jsValueEqual(lhs: JsAbiValue, rhs: JsAbiValue): boolean;
+  jsValueStrictlyEqual(lhs: JsAbiValue, rhs: JsAbiValue): boolean;
+  reflectApply(target: JsAbiValue, thisArgument: JsAbiValue, arguments: JsAbiValue[]): JsAbiResult;
+  reflectConstruct(target: JsAbiValue, arguments: JsAbiValue[]): JsAbiValue;
+  reflectDeleteProperty(target: JsAbiValue, propertyKey: string): boolean;
+  reflectGet(target: JsAbiValue, propertyKey: string): JsAbiResult;
+  reflectGetOwnPropertyDescriptor(target: JsAbiValue, propertyKey: string): JsAbiValue;
+  reflectGetPrototypeOf(target: JsAbiValue): JsAbiValue;
+  reflectHas(target: JsAbiValue, propertyKey: string): boolean;
+  reflectIsExtensible(target: JsAbiValue): boolean;
+  reflectOwnKeys(target: JsAbiValue): JsAbiValue[];
+  reflectPreventExtensions(target: JsAbiValue): boolean;
+  reflectSet(target: JsAbiValue, propertyKey: string, value: JsAbiValue): JsAbiResult;
+  reflectSetPrototypeOf(target: JsAbiValue, prototype: JsAbiValue): boolean;
+  dropJsAbiValue?: (val: JsAbiValue) => void;
+}
+export interface JsAbiValue {
+}