@yodaos-pkg/ink 0.3.0 → 0.6.0

package/{dist/env.js → env.js}

@@ -323,13 +323,10 @@ function createVaListReader(argsPtr) {
   };
 }
 
-function formatInteger(value, {
-  signed = true,
-  base = 10,
-  width = 0,
-  padZero = false,
-  uppercase = false,
-} = {}) {
+function formatInteger(
+  value,
+  { signed = true, base = 10, width = 0, padZero = false, uppercase = false } = {},
+) {
   let normalized = normalizePrintfValue(value);
   let negative = false;
   let digits = '';
@@ -358,13 +355,12 @@ function formatInteger(value, {
   }
 
   const prefix = negative ? '-' : '';
-  const paddedDigits = padZero && width > prefix.length + digits.length
-    ? digits.padStart(width - prefix.length, '0')
-    : digits;
+  const paddedDigits =
+    padZero && width > prefix.length + digits.length
+      ? digits.padStart(width - prefix.length, '0')
+      : digits;
   const result = `${prefix}${paddedDigits}`;
-  return !padZero && width > result.length
-    ? result.padStart(width, ' ')
-    : result;
+  return !padZero && width > result.length ? result.padStart(width, ' ') : result;
 }
 
 function formatStringValue(value, precision) {
@@ -564,7 +560,9 @@ export function vsnprintf(dst, size, fmtPtr, argsPtr) {
 }
 
 export function snprintf(dst, size, fmtPtr) {
-  return writeCString(dst, size, formatPrintf(fmtPtr, createDirectArgumentReader(arguments, 3))) | 0;
+  return (
+    writeCString(dst, size, formatPrintf(fmtPtr, createDirectArgumentReader(arguments, 3))) | 0
+  );
 }
 
 export function scalbn(x, n) {

package/index.d.ts

@@ -0,0 +1,365 @@
+/**
+ * A single bundle file payload accepted by the browser SDK.
+ *
+ * String values are encoded as UTF-8 text. Typed arrays and array buffers are
+ * forwarded as binary file contents without additional transformation.
+ */
+export type BundleFileInput = string | Uint8Array | ArrayBuffer | ArrayBufferView;
+
+/**
+ * A normalized bundle file collection accepted by bundle-loading helpers.
+ *
+ * File paths are repository-style relative paths inside the app bundle, such as
+ * `app.json`, `pages/home/index.js`, or `assets/logo.png`.
+ */
+export type BundleFiles =
+  | Map<string, BundleFileInput>
+  | Array<[string, BundleFileInput]>
+  | Record<string, BundleFileInput>;
+
+/**
+ * Shared initialization options used when the browser SDK needs to bootstrap
+ * the Ink WebAssembly runtime.
+ */
+export interface InitInkOptions {
+  /** Explicit URL for the Ink WebAssembly binary. */
+  wasmUrl?: string | URL | Request;
+  /** Preloaded module or alternative module source accepted by the wasm loader. */
+  moduleOrPath?: RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+  /** Optional proxy endpoint used by Ink's network compatibility layer. */
+  proxyUrl?: string;
+  /** Query parameter name that carries the original target URL when proxying. */
+  targetSearchParam?: string;
+  /** Request interceptor applied to compatibility-layer network requests. */
+  requestInterceptor?: InkRequestInterceptor;
+}
+
+/**
+ * Options used to construct a browser-side {@link InkView}.
+ */
+export interface CreateInkViewOptions {
+  /** Initial logical width in CSS pixels. */
+  width: number;
+  /** Initial logical height in CSS pixels. */
+  height: number;
+  /** Device pixel ratio override. Defaults to `window.devicePixelRatio` when available. */
+  scaleFactor?: number;
+  /** Optional canvas to bind immediately after creation. */
+  canvas?: HTMLCanvasElement;
+  /** Optional wasm bootstrap overrides. */
+  wasm?: InitInkOptions;
+}
+
+/**
+ * Opens an in-memory Ink app bundle that is already available in the host.
+ */
+export interface OpenBundleOptions {
+  /** Stable application identifier used by the runtime. */
+  appId: string;
+  /** Bundle file map or file list. */
+  files: BundleFiles;
+  /** 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.
+ */
+export interface LoadBundleFromVfsOptions {
+  /** Stable application identifier used by the runtime. */
+  appId: string;
+  /** Base URL that serves `manifest.json` and bundle files. */
+  baseUrl: string;
+  /** Optional fetch implementation override. */
+  fetch?: typeof globalThis.fetch;
+  /** Abort signal used while downloading the bundle. */
+  signal?: AbortSignal;
+  /** Additional request headers sent to the VFS host. */
+  headers?: HeadersInit;
+  /** Request interceptor applied to bundle download requests. */
+  requestInterceptor?: InkRequestInterceptor;
+}
+
+/**
+ * Loads a bundle from VFS and opens it immediately in the target view.
+ */
+export interface OpenFromVfsOptions extends LoadBundleFromVfsOptions {
+  /** Optional initial page route. */
+  initialPage?: string | null;
+  /** Optional launch query string or structured query object. */
+  query?: string | Record<string, unknown> | null;
+}
+
+/**
+ * Normalized request data passed to an {@link InkRequestInterceptor}.
+ */
+export interface InkInterceptedRequest {
+  url: string;
+  method: string;
+  headers: Record<string, string>;
+  body: BodyInit | ArrayBuffer | ArrayBufferView | Uint8Array | null;
+  metadata: Record<string, unknown>;
+}
+
+/**
+ * The action returned from an {@link InkRequestInterceptor}.
+ */
+export type InkInterceptedRequestAction =
+  | { action?: 'continue' }
+  | {
+      action: 'rewrite';
+      url?: string;
+      method?: string;
+      headers?: HeadersInit | Record<string, string>;
+      body?: BodyInit | ArrayBuffer | ArrayBufferView | Uint8Array | null;
+    }
+  | {
+      action: 'block';
+      reason?: string;
+    };
+
+export type InkRequestInterceptor = (
+  request: InkInterceptedRequest,
+) => InkInterceptedRequestAction | Promise<InkInterceptedRequestAction>;
+
+/**
+ * Applies global network compatibility configuration for the browser SDK.
+ */
+export interface ConfigureNetworkOptions {
+  proxyUrl?: string;
+  targetSearchParam?: string;
+  interceptor?: InkRequestInterceptor;
+  clear?: boolean;
+}
+
+/** Single file entry inside a VFS manifest. */
+export interface VfsManifestEntry {
+  path: string;
+  size?: number;
+  contentType?: string;
+  etag?: string;
+}
+
+/** Manifest payload returned by a VFS host. */
+export interface VfsManifest {
+  appId: string;
+  files: VfsManifestEntry[];
+}
+
+/** Fully downloaded bundle returned by {@link loadBundleFromVfs}. */
+export interface LoadedVfsBundle {
+  appId: string;
+  manifest: VfsManifest;
+  files: Map<string, Uint8Array>;
+}
+
+/**
+ * Customizes DOM event binding behavior for {@link InkView.bindDomEvents}.
+ */
+export interface BindDomEventsOptions {
+  /** Canvas used for pointer and wheel event binding. Defaults to the currently bound canvas. */
+  canvas?: HTMLCanvasElement;
+  /** Keyboard event target, typically `window`, `document`, or a focusable element. */
+  keyboardTarget?: EventTarget | null;
+  /** Element that should receive focus/blur synchronization for the Ink instance. */
+  focusTarget?: HTMLElement | HTMLCanvasElement | null;
+  /** Whether wheel events should call `preventDefault()` before forwarding. */
+  preventWheelDefault?: boolean;
+}
+
+/**
+ * Initializes the browser SDK and ensures the wasm runtime is ready to create
+ * views. Most applications can use {@link InkView.create} or
+ * {@link createInkView} directly, which call this lazily when needed.
+ */
+export declare function initInk(options?: InitInkOptions): Promise<{
+  InkWebView: unknown;
+  getInkVersion: () => string;
+}>;
+
+/** Returns the Ink runtime version string exported by the wasm module. */
+export declare function getInkVersion(): string;
+
+/** Normalizes supported bundle file inputs into a UTF-8 / binary file map. */
+export declare function normalizeBundleFiles(files: BundleFiles): Map<string, Uint8Array>;
+
+/** Serializes a launch query into the format expected by the Ink runtime. */
+export declare function serializeQuery(
+  query: string | Record<string, unknown> | null | undefined,
+): string | null;
+
+/** Creates an interceptor that rewrites requests through a proxy endpoint. */
+export declare function createProxyUrlResolver(options: {
+  proxyUrl: string;
+  targetSearchParam?: string;
+}): InkRequestInterceptor;
+
+/** Registers the global request interceptor used by browser compatibility networking. */
+export declare function setInkRequestInterceptor(
+  interceptor: InkRequestInterceptor | null | undefined,
+): void;
+
+/** Clears the global request interceptor. */
+export declare function clearInkRequestInterceptor(): void;
+
+/** Applies global browser compatibility network settings. */
+export declare function configureNetwork(options?: ConfigureNetworkOptions): void;
+
+/** Creates manifest and file URLs for a VFS-served bundle. */
+export declare function createVfsUrls(input: { baseUrl: string; appId: string }): {
+  manifestUrl: string;
+  fileUrl(filePath: string): string;
+};
+
+/** Downloads and materializes a VFS bundle into memory without opening it. */
+export declare function loadBundleFromVfs(
+  options: LoadBundleFromVfsOptions,
+): Promise<LoadedVfsBundle>;
+
+/**
+ * Browser host wrapper around the wasm `InkWebView`.
+ *
+ * `InkView` owns the runtime instance, optional canvas binding, DOM event
+ * forwarding, and render loop orchestration for one Ink application surface.
+ * A typical flow is:
+ *
+ * 1. Create a view with {@link InkView.create}.
+ * 2. Bind a canvas and DOM events if needed.
+ * 3. Open an in-memory bundle or load one from VFS.
+ * 4. Render manually with {@link render} or start the internal loop with
+ *    {@link startRendering}.
+ * 5. Dispose the view with {@link destroy} when the host is done.
+ */
+export declare class InkView {
+  /**
+   * Creates a browser-side Ink view and bootstraps the wasm runtime if needed.
+   *
+   * If `options.canvas` is provided, the canvas is bound immediately. The view
+   * is created without opening an app bundle; call {@link openBundle} or
+   * {@link openFromVfs} afterwards.
+   */
+  static create(options: CreateInkViewOptions): Promise<InkView>;
+
+  /**
+   * Binds or rebinds the canvas used for drawing the current view.
+   *
+   * Rebinding is useful when the host recreates a canvas element while keeping
+   * the same Ink runtime instance alive.
+   */
+  bindCanvas(canvas: HTMLCanvasElement): this;
+
+  /**
+   * Registers the common DOM event bridges used by Ink in the browser.
+   *
+   * This helper wires pointer, wheel, keyboard, and focus/blur forwarding to
+   * the underlying wasm view. It returns an unbind function that should be
+   * called before replacing the canvas, removing the host element, or
+   * destroying the view.
+   */
+  bindDomEvents(options?: BindDomEventsOptions): () => void;
+
+  /**
+   * Opens an already-materialized application bundle.
+   *
+   * The bundle is normalized in memory and passed directly to the runtime. This
+   * call returns the current view for chaining.
+   */
+  openBundle(options: OpenBundleOptions): this;
+
+  /**
+   * Downloads a bundle from a VFS host and opens it in the current view.
+   *
+   * The returned promise resolves with the downloaded bundle payload after the
+   * app has been opened successfully.
+   */
+  openFromVfs(options: OpenFromVfsOptions): Promise<LoadedVfsBundle>;
+
+  /**
+   * Resizes the logical surface and optionally updates the scale factor.
+   *
+   * Hosts should call this whenever the canvas size or device pixel ratio
+   * changes.
+   */
+  resize(width: number, height: number, scaleFactor?: number): this;
+
+  /** Forwards a host focus event so the Ink instance can accept focus-dependent input. */
+  focus(): this;
+
+  /** Forwards a host blur event so the Ink instance stops behaving as focused. */
+  blur(): this;
+
+  /**
+   * Controls whether this view currently accepts interaction-gated work.
+   *
+   * When set to `false`, keyboard events and voice wakeup are dropped before
+   * reaching the runtime, and new interaction-gated capabilities fail fast.
+   * This includes recording, speech recognition, photo capture, and Bluetooth
+   * `requestDevice()`, `scanDevices()`, `connect()`, and
+   * `startNotifications()`.
+   *
+   * Existing active sessions are not force-stopped by this toggle.
+   */
+  setInteractive(interactive: boolean): this;
+
+  /** Returns the current host-visible interactive flag for this view. */
+  isInteractive(): boolean;
+
+  /**
+   * Notifies the runtime that the host has observed a trusted user interaction.
+   *
+   * This is useful in browser environments where some APIs require a recent
+   * user gesture signal.
+   */
+  notifyUserInteraction(): this;
+
+  /**
+   * Performs one render pass immediately.
+   *
+   * Returns `true` when the frame produced visible work and `false` when
+   * nothing needed to be drawn.
+   */
+  render(): boolean;
+
+  /** Marks the view as needing another frame on the next render opportunity. */
+  requestRender(): this;
+
+  /**
+   * Starts the internal animation/render loop.
+   *
+   * Use this when the host wants Ink to schedule frames automatically with
+   * `requestAnimationFrame`.
+   */
+  startRendering(): this;
+
+  /** Stops the internal animation/render loop started by {@link startRendering}. */
+  stopRendering(): this;
+
+  /** Returns whether the internal render loop is currently active. */
+  isRunning(): boolean;
+
+  /**
+   * Releases the underlying wasm view and detaches associated host resources.
+   *
+   * Hosts should unbind DOM events before calling this if they previously used
+   * {@link bindDomEvents}.
+   */
+  destroy(): void;
+}
+
+/** Convenience factory equivalent to {@link InkView.create}. */
+export declare function createInkView(options: CreateInkViewOptions): Promise<InkView>;
+
+/**
+ * Creates the small helper set consumed by framework integrations and adapters.
+ */
+export declare function createFrameworkBindings(): {
+  ensureLeadingSlash(path: string): string;
+  initInk: typeof initInk;
+  createInkView: typeof createInkView;
+  configureNetwork: typeof configureNetwork;
+  setInkRequestInterceptor: typeof setInkRequestInterceptor;
+  clearInkRequestInterceptor: typeof clearInkRequestInterceptor;
+  createProxyUrlResolver: typeof createProxyUrlResolver;
+};

package/{dist/index.js → index.js}

@@ -546,6 +546,15 @@ export class InkView {
     return this;
   }
 
+  setInteractive(interactive) {
+    this.#rawView.setInteractive(Boolean(interactive));
+    return this;
+  }
+
+  isInteractive() {
+    return Boolean(this.#rawView.isInteractive());
+  }
+
   notifyUserInteraction() {
     this.#rawView.notifyUserInteraction();
     return this;

package/package.json

@@ -1,24 +1,20 @@
 {
   "name": "@yodaos-pkg/ink",
-  "version": "0.3.0",
   "description": "Ink Web SDK for browser rendering and VFS-backed app loading",
-  "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "files": [
-    "dist/"
-  ],
-  "scripts": {
-    "build": "node scripts/build.js",
-    "test": "npm run build && node --test test/**/*.test.js"
-  },
   "repository": {
     "type": "git",
-    "url": "https://github.com/jsar-project/ink"
+    "url": "git+https://github.com/jsar-project/ink.git"
   },
+  "license": "Apache-2.0",
   "publishConfig": {
     "access": "public",
-    "registry": "https://registry.npmjs.org/"
+    "registry": "https://registry.npmjs.com/"
   },
-  "license": "ISC"
-}
+  "version": "0.6.0",
+  "type": "module",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "files": [
+    "*"
+  ]
+}

package/{dist/pkg → pkg}/ink_web.d.ts

@@ -10,12 +10,14 @@ export class InkWebView {
     dispatchInput(event_type: string, code: string, timestamp: number): 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;
     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;
+    setInteractive(interactive: boolean): void;
 }
 
 export function get_version(): string;
@@ -34,18 +36,20 @@ export interface InitOutput {
     readonly inkwebview_dispatchInput: (a: number, b: number, c: number, d: number, e: number, f: number, g: 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_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_8658: (a: number, b: number) => void;
-    readonly __wasm_bindgen_func_elem_12847: (a: number, b: number) => void;
-    readonly __wasm_bindgen_func_elem_8747: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_12848: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_8748: (a: number, b: number) => 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 __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/{dist/pkg → pkg}/ink_web.js

@@ -82,6 +82,13 @@ export class InkWebView {
     focus() {
         wasm.inkwebview_focus(this.__wbg_ptr);
     }
+    /**
+     * @returns {boolean}
+     */
+    isInteractive() {
+        const ret = wasm.inkwebview_isInteractive(this.__wbg_ptr);
+        return ret !== 0;
+    }
     /**
      * @returns {boolean}
      */
@@ -154,6 +161,12 @@ export class InkWebView {
     resize(width, height, scale_factor) {
         wasm.inkwebview_resize(this.__wbg_ptr, width, height, scale_factor);
     }
+    /**
+     * @param {boolean} interactive
+     */
+    setInteractive(interactive) {
+        wasm.inkwebview_setInteractive(this.__wbg_ptr, interactive);
+    }
 }
 if (Symbol.dispose) InkWebView.prototype[Symbol.dispose] = InkWebView.prototype.free;
 
@@ -967,28 +980,28 @@ function __wbg_get_imports() {
             return ret;
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 2300, function: Function { arguments: [NamedExternref("CloseEvent")], shim_idx: 2304, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_8658, __wasm_bindgen_func_elem_8747);
+            // 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);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 2300, function: Function { arguments: [NamedExternref("Event")], shim_idx: 2304, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_8658, __wasm_bindgen_func_elem_8747);
+            // 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);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000003: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 2300, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 2304, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_8658, __wasm_bindgen_func_elem_8747);
+            // 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);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000004: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 2300, function: Function { arguments: [], shim_idx: 2301, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_8658, __wasm_bindgen_func_elem_8748);
+            // 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);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000005: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 3264, function: Function { arguments: [Externref], shim_idx: 3265, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_12847, __wasm_bindgen_func_elem_12848);
+            // 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);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000006: function(arg0) {
@@ -1045,16 +1058,16 @@ function __wbg_get_imports() {
     };
 }
 
-function __wasm_bindgen_func_elem_8748(arg0, arg1) {
-    wasm.__wasm_bindgen_func_elem_8748(arg0, arg1);
+function __wasm_bindgen_func_elem_9383(arg0, arg1) {
+    wasm.__wasm_bindgen_func_elem_9383(arg0, arg1);
 }
 
-function __wasm_bindgen_func_elem_8747(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_8747(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_9385(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_9385(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wasm_bindgen_func_elem_12848(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_12848(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_13335(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_13335(arg0, arg1, addHeapObject(arg2));
 }
 
 

package/{dist/pkg → pkg}/ink_web_bg.wasm.d.ts

@@ -9,18 +9,20 @@ 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_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_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_8658: (a: number, b: number) => void;
-export const __wasm_bindgen_func_elem_12847: (a: number, b: number) => void;
-export const __wasm_bindgen_func_elem_8747: (a: number, b: number, c: number) => void;
-export const __wasm_bindgen_func_elem_12848: (a: number, b: number, c: number) => void;
-export const __wasm_bindgen_func_elem_8748: (a: number, b: number) => 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 __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;