@yodaos-pkg/ink 0.6.0 → 0.7.0

package/README.md

@@ -176,6 +176,94 @@ Binds common DOM events to the current `InkView`.
   - Returns a cleanup function
   - Calling it removes every listener created by this binding call
 
+### `view.dispatchMessageEvent(dataOrJson, origin?, lastEventId?)`
+
+Dispatches a one-shot host message to the current Ink page.
+
+**Parameters**
+
+- `dataOrJson: unknown`
+  - Required
+  - Accepts either a structured JSON-serializable value or a raw JSON string
+- `origin?: string`
+  - Optional
+  - The host-defined origin exposed as `event.origin`
+  - Defaults to `'host'`
+- `lastEventId?: string`
+  - Optional
+  - The host-defined message identifier exposed as `event.lastEventId`
+  - Defaults to `''`
+
+**What it does**
+
+- If `dataOrJson` is a string, parses it as raw JSON first
+- Otherwise serializes the structured value directly
+- Dispatches the resulting payload as a DOM-style `MessageEvent`
+- Automatically triggers a render request
+
+**Returns**
+
+- `InkView`
+  - Returns the current instance so it can be chained
+
+**Throws**
+
+- `Error`
+  - If a string input is not valid JSON
+- `TypeError`
+  - If a structured input cannot be serialized into JSON
+
+### `view.createMessageStream(origin?, lastEventId?)`
+
+Creates a host-controlled JSON message stream for the current Ink page.
+
+**Parameters**
+
+- `origin?: string`
+  - Optional
+  - The host-defined origin propagated to stream events
+  - Defaults to `'host'`
+- `lastEventId?: string`
+  - Optional
+  - The host-defined message identifier propagated to stream events
+  - Defaults to `''`
+
+**What it does**
+
+- Creates a progressive JSON stream owned by the browser host
+- Lets the host call `write(chunk)` repeatedly
+- Lets the host call `close()` when the stream is complete
+- Delivers a runtime-side `MessageStream` object through `onMessage(event)`
+
+**Returns**
+
+- `InkHostMessageStream`
+  - A small host-side stream handle with `write(chunk)` and `close()`
+
+### `InkHostMessageStream.write(chunk)`
+
+Appends the next JSON text chunk to the stream.
+
+**Parameters**
+
+- `chunk: string`
+  - Required
+  - The next JSON text fragment to append
+
+**Throws**
+
+- `Error`
+  - If the stream has already been closed
+
+### `InkHostMessageStream.close()`
+
+Closes the host stream.
+
+**What it does**
+
+- Ends the stream inside the Ink runtime
+- Is safe to call more than once
+
 ### `view.openBundle(options)`
 
 Opens an Ink bundle that already exists in memory.
@@ -328,6 +416,70 @@ Destroys the current `InkView` and releases its resources.
 
 - `void`
 
+## Host Message Example
+
+Use `dispatchMessageEvent()` when the full payload is already available:
+
+```js
+view.dispatchMessageEvent(
+  { type: 'hello', value: 1 },
+  'browser-host',
+  'msg-1',
+);
+
+view.dispatchMessageEvent(
+  '{"type":"hello","value":2}',
+  'browser-host',
+  'msg-2',
+);
+```
+
+Inside the Ink page:
+
+```js
+export default Page({
+  onMessage(event) {
+    console.log('message data:', event.data);
+    console.log('origin:', event.origin);
+    console.log('lastEventId:', event.lastEventId);
+  },
+});
+```
+
+## Host Message Stream Example
+
+Use `createMessageStream()` when JSON arrives progressively:
+
+```js
+const stream = view.createMessageStream('browser-host', 'stream-1');
+stream.write('{"delta":"hel"');
+stream.write('lo"}{"done":true}');
+stream.close();
+```
+
+Inside the Ink page:
+
+```js
+export default Page({
+  onMessage(event) {
+    if (!(event.data instanceof MessageStream)) {
+      return;
+    }
+
+    const stream = event.data;
+    stream.addEventListener('token', (tokenEvent) => {
+      console.log('token:', tokenEvent.token);
+    });
+    stream.addEventListener('error', (errorEvent) => {
+      console.error('stream error:', errorEvent.error);
+    });
+    stream.addEventListener('end', () => {
+      console.log('stream finished');
+    });
+  },
+});
+```
+
 ## Plain JavaScript Integration
 
 This is the most direct way to integrate Ink into a plain JavaScript app.

package/index.d.ts

@@ -64,6 +64,18 @@ export interface OpenBundleOptions {
   query?: string | Record<string, unknown> | null;
 }
 
+/**
+ * Opens a runtime-owned builtin app through a path such as `ink://launchers`.
+ */
+export interface OpenPathOptions {
+  /** Runtime path to open, typically using the `ink://` scheme for builtin apps. */
+  path: string;
+  /** Optional initial page route. */
+  initialPage?: string | null;
+  /** Optional launch query string or structured query object. */
+  query?: string | Record<string, unknown> | null;
+}
+
 /**
  * Base options for loading a bundle from a VFS-style HTTP endpoint.
  */
@@ -169,6 +181,20 @@ export interface BindDomEventsOptions {
   preventWheelDefault?: boolean;
 }
 
+/**
+ * Host-controlled message stream returned by {@link InkView.createMessageStream}.
+ *
+ * Chunks are UTF-8 JSON text fragments consumed incrementally by the Ink
+ * runtime. JavaScript inside Ink receives a runtime-side `MessageStream`
+ * object through `onMessage(event)`.
+ */
+export interface InkHostMessageStream {
+  /** Appends the next JSON text chunk to the stream. */
+  write(chunk: string): void;
+  /** Closes the stream and emits terminal events inside the Ink runtime. */
+  close(): void;
+}
+
 /**
  * Initializes the browser SDK and ensures the wasm runtime is ready to create
  * views. Most applications can use {@link InkView.create} or
@@ -260,6 +286,19 @@ export declare class InkView {
    */
   bindDomEvents(options?: BindDomEventsOptions): () => void;
 
+  /**
+   * Opens a runtime path such as `ink://launchers`.
+   *
+   * On web/wasm this currently targets runtime-owned builtin apps. Browser
+   * hosts should continue to use {@link openBundle} or {@link openFromVfs}
+   * when they own the bundle contents directly.
+   */
+  open(
+    path: string,
+    initialPage?: string | null,
+    query?: string | Record<string, unknown> | null,
+  ): this;
+
   /**
    * Opens an already-materialized application bundle.
    *
@@ -314,6 +353,24 @@ export declare class InkView {
    */
   notifyUserInteraction(): this;
 
+  /**
+   * Dispatches a one-shot host message to the current Ink page.
+   *
+   * When `dataOrJson` is a string, the SDK parses it as raw JSON first so the
+   * browser behavior matches Android's `dispatchMessageEvent(json, ...)`
+   * overload. Otherwise the value is serialized directly as the message
+   * payload.
+   */
+  dispatchMessageEvent(dataOrJson: unknown, origin?: string, lastEventId?: string): this;
+
+  /**
+   * Creates a host-controlled JSON message stream for the current Ink page.
+   *
+   * The returned handle accepts `write(chunk)` and `close()`, while the Ink
+   * page receives a runtime-side `MessageStream` object through `onMessage`.
+   */
+  createMessageStream(origin?: string, lastEventId?: string): InkHostMessageStream;
+
   /**
    * Performs one render pass immediately.
    *

package/index.js

@@ -278,6 +278,70 @@ function ensureAnimationFrameApi() {
   };
 }
 
+function normalizeHostMessageMetadata(origin, lastEventId) {
+  if (typeof origin !== 'string') {
+    throw new TypeError('`origin` must be a string.');
+  }
+  if (typeof lastEventId !== 'string') {
+    throw new TypeError('`lastEventId` must be a string.');
+  }
+  return { origin, lastEventId };
+}
+
+function normalizeHostMessagePayload(dataOrJson) {
+  if (typeof dataOrJson === 'string') {
+    try {
+      return JSON.parse(dataOrJson);
+    } catch {
+      throw new Error('dispatchMessageEvent(json) requires valid JSON');
+    }
+  }
+  return dataOrJson;
+}
+
+function serializeHostMessagePayload(dataOrJson) {
+  const payload = normalizeHostMessagePayload(dataOrJson);
+  let payloadJson;
+  try {
+    payloadJson = JSON.stringify(payload);
+  } catch {
+    throw new TypeError('dispatchMessageEvent(data) requires a JSON-serializable value.');
+  }
+  if (typeof payloadJson !== 'string') {
+    throw new TypeError('dispatchMessageEvent(data) requires a JSON-serializable value.');
+  }
+  return payloadJson;
+}
+
+class InkHostMessageStream {
+  #rawStream;
+  #requestRender;
+  #closed;
+
+  constructor(rawStream, requestRender) {
+    this.#rawStream = rawStream;
+    this.#requestRender = requestRender;
+    this.#closed = false;
+  }
+
+  write(chunk) {
+    if (typeof chunk !== 'string') {
+      throw new TypeError('`chunk` must be a string.');
+    }
+    this.#rawStream.write(chunk);
+    this.#requestRender();
+  }
+
+  close() {
+    if (this.#closed) {
+      return;
+    }
+    this.#rawStream.close();
+    this.#closed = true;
+    this.#requestRender();
+  }
+}
+
 export async function initInk(options = {}) {
   if (options.requestInterceptor) {
     setInkRequestInterceptor(options.requestInterceptor);
@@ -331,6 +395,7 @@ export class InkView {
   #animationFrameApi;
   #frameHandle;
   #autoRender;
+  #destroyed;
   #domCleanup;
 
   constructor(rawView, options = {}) {
@@ -339,6 +404,7 @@ export class InkView {
     this.#animationFrameApi = ensureAnimationFrameApi();
     this.#frameHandle = null;
     this.#autoRender = false;
+    this.#destroyed = false;
     this.#domCleanup = null;
   }
 
@@ -503,6 +569,16 @@ export class InkView {
     return this;
   }
 
+  open(path, initialPage = null, query = null) {
+    if (typeof path !== 'string' || !path.trim()) {
+      throw new Error('`path` must be a non-empty string.');
+    }
+
+    this.#rawView.open(path.trim(), initialPage, serializeQuery(query));
+    this.requestRender();
+    return this;
+  }
+
   async openFromVfs({
     appId,
     baseUrl,
@@ -560,7 +636,29 @@ export class InkView {
     return this;
   }
 
+  dispatchMessageEvent(dataOrJson, origin = 'host', lastEventId = '') {
+    const metadata = normalizeHostMessageMetadata(origin, lastEventId);
+    this.#rawView.dispatchMessageEvent(
+      serializeHostMessagePayload(dataOrJson),
+      metadata.origin,
+      metadata.lastEventId,
+    );
+    this.requestRender();
+    return this;
+  }
+
+  createMessageStream(origin = 'host', lastEventId = '') {
+    const metadata = normalizeHostMessageMetadata(origin, lastEventId);
+    return new InkHostMessageStream(
+      this.#rawView.createMessageStream(metadata.origin, metadata.lastEventId),
+      () => this.requestRender(),
+    );
+  }
+
   render() {
+    if (this.#destroyed) {
+      return false;
+    }
     const hasMoreWork = Boolean(this.#rawView.render());
     if (hasMoreWork || this.#autoRender) {
       this.requestRender();
@@ -569,6 +667,9 @@ export class InkView {
   }
 
   requestRender() {
+    if (this.#destroyed) {
+      return this;
+    }
     if (this.#frameHandle != null) {
       return this;
     }
@@ -600,6 +701,10 @@ export class InkView {
   }
 
   destroy() {
+    if (this.#destroyed) {
+      return;
+    }
+    this.#destroyed = true;
     this.stopRendering();
     if (this.#domCleanup) {
       this.#domCleanup();

package/package.json

@@ -10,7 +10,7 @@
     "access": "public",
     "registry": "https://registry.npmjs.com/"
   },
-  "version": "0.6.0",
+  "version": "0.7.0",
   "type": "module",
   "main": "index.js",
   "types": "index.d.ts",

package/pkg/ink_web.d.ts

@@ -1,19 +1,30 @@
 /* tslint:disable */
 /* eslint-disable */
 
+export class InkWebMessageStream {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    close(): void;
+    write(chunk: string): void;
+}
+
 export class InkWebView {
     free(): void;
     [Symbol.dispose](): void;
     bindCanvas(canvas: HTMLCanvasElement): void;
     blur(): void;
+    createMessageStream(origin: string, last_event_id: string): InkWebMessageStream;
     destroy(): void;
     dispatchInput(event_type: string, code: string, timestamp: number): void;
+    dispatchMessageEvent(payload_json: string, origin: string, last_event_id: string): void;
     dispatchPointer(event_type: string, x: number, y: number, id: number, button: number, delta_x: number, delta_y: number): void;
     focus(): void;
     isInteractive(): boolean;
     isRunning(): boolean;
     constructor(width: number, height: number, scale_factor: number);
     notifyUserInteraction(): void;
+    open(path: string, initial_page?: string | null, query_json?: string | null): void;
     openBundle(app_id: string, files: Map<any, any>, initial_page?: string | null, query_json?: string | null): void;
     render(): boolean;
     resize(width: number, height: number, scale_factor: number): void;
@@ -28,28 +39,34 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 
 export interface InitOutput {
     readonly memory: WebAssembly.Memory;
+    readonly __wbg_inkwebmessagestream_free: (a: number, b: number) => void;
     readonly __wbg_inkwebview_free: (a: number, b: number) => void;
     readonly get_version: (a: number) => void;
+    readonly inkwebmessagestream_close: (a: number) => void;
+    readonly inkwebmessagestream_write: (a: number, b: number, c: number, d: number) => void;
     readonly inkwebview_bindCanvas: (a: number, b: number, c: number) => void;
     readonly inkwebview_blur: (a: number) => void;
+    readonly inkwebview_createMessageStream: (a: number, b: number, c: number, d: number, e: number) => number;
     readonly inkwebview_destroy: (a: number) => void;
     readonly inkwebview_dispatchInput: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly inkwebview_dispatchMessageEvent: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
     readonly inkwebview_dispatchPointer: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
     readonly inkwebview_focus: (a: number) => void;
     readonly inkwebview_isInteractive: (a: number) => number;
     readonly inkwebview_isRunning: (a: number) => number;
     readonly inkwebview_new: (a: number, b: number, c: number) => number;
     readonly inkwebview_notifyUserInteraction: (a: number) => void;
+    readonly inkwebview_open: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
     readonly inkwebview_openBundle: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
     readonly inkwebview_render: (a: number, b: number) => void;
     readonly inkwebview_resize: (a: number, b: number, c: number, d: number) => void;
     readonly inkwebview_setInteractive: (a: number, b: number) => void;
     readonly main: () => void;
-    readonly __wasm_bindgen_func_elem_9121: (a: number, b: number) => void;
-    readonly __wasm_bindgen_func_elem_13334: (a: number, b: number) => void;
-    readonly __wasm_bindgen_func_elem_9385: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_13335: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_9383: (a: number, b: number) => void;
+    readonly __wasm_bindgen_func_elem_9251: (a: number, b: number) => void;
+    readonly __wasm_bindgen_func_elem_13498: (a: number, b: number) => void;
+    readonly __wasm_bindgen_func_elem_9547: (a: number, b: number, c: number) => void;
+    readonly __wasm_bindgen_func_elem_13499: (a: number, b: number, c: number) => void;
+    readonly __wasm_bindgen_func_elem_9546: (a: number, b: number) => void;
     readonly __wbindgen_export: (a: number, b: number) => number;
     readonly __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
     readonly __wbindgen_export3: (a: number) => void;

package/pkg/ink_web.js

@@ -1,5 +1,47 @@
 /* @ts-self-types="./ink_web.d.ts" */
 
+export class InkWebMessageStream {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(InkWebMessageStream.prototype);
+        obj.__wbg_ptr = ptr;
+        InkWebMessageStreamFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        InkWebMessageStreamFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_inkwebmessagestream_free(ptr, 0);
+    }
+    close() {
+        wasm.inkwebmessagestream_close(this.__wbg_ptr);
+    }
+    /**
+     * @param {string} chunk
+     */
+    write(chunk) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(chunk, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.inkwebmessagestream_write(retptr, this.__wbg_ptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+}
+if (Symbol.dispose) InkWebMessageStream.prototype[Symbol.dispose] = InkWebMessageStream.prototype.free;
+
 export class InkWebView {
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
@@ -30,6 +72,19 @@ export class InkWebView {
     blur() {
         wasm.inkwebview_blur(this.__wbg_ptr);
     }
+    /**
+     * @param {string} origin
+     * @param {string} last_event_id
+     * @returns {InkWebMessageStream}
+     */
+    createMessageStream(origin, last_event_id) {
+        const ptr0 = passStringToWasm0(origin, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(last_event_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.inkwebview_createMessageStream(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        return InkWebMessageStream.__wrap(ret);
+    }
     destroy() {
         wasm.inkwebview_destroy(this.__wbg_ptr);
     }
@@ -55,6 +110,30 @@ export class InkWebView {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * @param {string} payload_json
+     * @param {string} origin
+     * @param {string} last_event_id
+     */
+    dispatchMessageEvent(payload_json, origin, last_event_id) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(payload_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(origin, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            const ptr2 = passStringToWasm0(last_event_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len2 = WASM_VECTOR_LEN;
+            wasm.inkwebview_dispatchMessageEvent(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * @param {string} event_type
      * @param {number} x
@@ -110,6 +189,30 @@ export class InkWebView {
     notifyUserInteraction() {
         wasm.inkwebview_notifyUserInteraction(this.__wbg_ptr);
     }
+    /**
+     * @param {string} path
+     * @param {string | null} [initial_page]
+     * @param {string | null} [query_json]
+     */
+    open(path, initial_page, query_json) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(path, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            var ptr1 = isLikeNone(initial_page) ? 0 : passStringToWasm0(initial_page, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var len1 = WASM_VECTOR_LEN;
+            var ptr2 = isLikeNone(query_json) ? 0 : passStringToWasm0(query_json, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            var len2 = WASM_VECTOR_LEN;
+            wasm.inkwebview_open(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * @param {string} app_id
      * @param {Map<any, any>} files
@@ -748,6 +851,10 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).read();
             return addHeapObject(ret);
         },
+        __wbg_readyState_1bb73ec7b8a54656: function(arg0) {
+            const ret = getObject(arg0).readyState;
+            return ret;
+        },
         __wbg_rect_967665357db991e9: function(arg0, arg1, arg2, arg3, arg4) {
             getObject(arg0).rect(arg1, arg2, arg3, arg4);
         },
@@ -980,28 +1087,28 @@ function __wbg_get_imports() {
             return ret;
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 2469, function: Function { arguments: [NamedExternref("CloseEvent")], shim_idx: 2402, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_9121, __wasm_bindgen_func_elem_9385);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 2443, function: Function { arguments: [NamedExternref("CloseEvent")], shim_idx: 2403, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_9251, __wasm_bindgen_func_elem_9547);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 2469, function: Function { arguments: [NamedExternref("Event")], shim_idx: 2402, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_9121, __wasm_bindgen_func_elem_9385);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 2443, function: Function { arguments: [NamedExternref("Event")], shim_idx: 2403, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_9251, __wasm_bindgen_func_elem_9547);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000003: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 2469, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 2402, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_9121, __wasm_bindgen_func_elem_9385);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 2443, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 2403, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_9251, __wasm_bindgen_func_elem_9547);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000004: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 2469, function: Function { arguments: [], shim_idx: 2470, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_9121, __wasm_bindgen_func_elem_9383);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 2443, function: Function { arguments: [], shim_idx: 2445, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_9251, __wasm_bindgen_func_elem_9546);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000005: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 3378, function: Function { arguments: [Externref], shim_idx: 3379, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_13334, __wasm_bindgen_func_elem_13335);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 3416, function: Function { arguments: [Externref], shim_idx: 3417, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_13498, __wasm_bindgen_func_elem_13499);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000006: function(arg0) {
@@ -1058,20 +1165,23 @@ function __wbg_get_imports() {
     };
 }
 
-function __wasm_bindgen_func_elem_9383(arg0, arg1) {
-    wasm.__wasm_bindgen_func_elem_9383(arg0, arg1);
+function __wasm_bindgen_func_elem_9546(arg0, arg1) {
+    wasm.__wasm_bindgen_func_elem_9546(arg0, arg1);
 }
 
-function __wasm_bindgen_func_elem_9385(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_9385(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_9547(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_9547(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wasm_bindgen_func_elem_13335(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_13335(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_13499(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_13499(arg0, arg1, addHeapObject(arg2));
 }
 
 
 const __wbindgen_enum_BinaryType = ["blob", "arraybuffer"];
+const InkWebMessageStreamFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_inkwebmessagestream_free(ptr >>> 0, 1));
 const InkWebViewFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_inkwebview_free(ptr >>> 0, 1));

package/pkg/ink_web_bg.wasm.d.ts

@@ -1,28 +1,34 @@
 /* tslint:disable */
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
+export const __wbg_inkwebmessagestream_free: (a: number, b: number) => void;
 export const __wbg_inkwebview_free: (a: number, b: number) => void;
 export const get_version: (a: number) => void;
+export const inkwebmessagestream_close: (a: number) => void;
+export const inkwebmessagestream_write: (a: number, b: number, c: number, d: number) => void;
 export const inkwebview_bindCanvas: (a: number, b: number, c: number) => void;
 export const inkwebview_blur: (a: number) => void;
+export const inkwebview_createMessageStream: (a: number, b: number, c: number, d: number, e: number) => number;
 export const inkwebview_destroy: (a: number) => void;
 export const inkwebview_dispatchInput: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+export const inkwebview_dispatchMessageEvent: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
 export const inkwebview_dispatchPointer: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number, j: number) => void;
 export const inkwebview_focus: (a: number) => void;
 export const inkwebview_isInteractive: (a: number) => number;
 export const inkwebview_isRunning: (a: number) => number;
 export const inkwebview_new: (a: number, b: number, c: number) => number;
 export const inkwebview_notifyUserInteraction: (a: number) => void;
+export const inkwebview_open: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
 export const inkwebview_openBundle: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
 export const inkwebview_render: (a: number, b: number) => void;
 export const inkwebview_resize: (a: number, b: number, c: number, d: number) => void;
 export const inkwebview_setInteractive: (a: number, b: number) => void;
 export const main: () => void;
-export const __wasm_bindgen_func_elem_9121: (a: number, b: number) => void;
-export const __wasm_bindgen_func_elem_13334: (a: number, b: number) => void;
-export const __wasm_bindgen_func_elem_9385: (a: number, b: number, c: number) => void;
-export const __wasm_bindgen_func_elem_13335: (a: number, b: number, c: number) => void;
-export const __wasm_bindgen_func_elem_9383: (a: number, b: number) => void;
+export const __wasm_bindgen_func_elem_9251: (a: number, b: number) => void;
+export const __wasm_bindgen_func_elem_13498: (a: number, b: number) => void;
+export const __wasm_bindgen_func_elem_9547: (a: number, b: number, c: number) => void;
+export const __wasm_bindgen_func_elem_13499: (a: number, b: number, c: number) => void;
+export const __wasm_bindgen_func_elem_9546: (a: number, b: number) => void;
 export const __wbindgen_export: (a: number, b: number) => number;
 export const __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
 export const __wbindgen_export3: (a: number) => void;