@yodaos-pkg/ink 0.1.0 → 0.2.0

package/README.md

@@ -36,8 +36,7 @@ Before integrating the SDK, make sure you have one of these two inputs:
    - This is a good fit when assets live on the server and the browser fetches
      them on demand.
 
-If you use the VFS flow, the server side usually works together with
-`@yodaos-pkg/ink-vfs-server`.
+If you use the VFS flow, provide your own HTTP VFS endpoint on the server side.
 
 ## Installation
 
@@ -47,10 +46,11 @@ If you use the VFS flow, the server side usually works together with
 npm install @yodaos-pkg/ink
 ```
 
-If you also want to use the VFS flow, install the server package as well:
+If you also want to use the VFS flow, prepare an HTTP endpoint that exposes:
 
-```bash
-npm install @yodaos-pkg/ink-vfs-server
+```text
+GET /apps/:appId/manifest
+GET /apps/:appId/files/:path
 ```
 
 ## Core API
@@ -94,6 +94,54 @@ Creates an `InkView` instance and initializes the wasm runtime internally.
   - Resolves to an `InkView` instance that can then call
     `bindDomEvents()`, `openBundle()`, and `openFromVfs()`
 
+### `configureNetwork(options)`
+
+Configures host-controlled request interception for Ink network traffic.
+
+**Parameters**
+
+- `options.interceptor`
+  - Optional
+  - A function that receives the outgoing request and returns an action
+- `options.proxyUrl`
+  - Optional
+  - A convenience option for rewriting requests through a proxy endpoint
+- `options.targetSearchParam`
+  - Optional
+  - The query parameter name used when `proxyUrl` is provided
+- `options.clear`
+  - Optional
+  - Clears the previously registered interceptor
+
+**What it does**
+
+- Registers a global Ink request interceptor
+- Lets hosts continue, rewrite, or block outgoing requests
+- Mirrors the shape of a WebView-style request interception hook
+
+**Returns**
+
+- `void`
+
+### `createProxyUrlResolver(options)`
+
+Creates a request interceptor that rewrites outgoing requests to a host-managed
+proxy endpoint such as `'/__proxy?url=...'`.
+
+**Parameters**
+
+- `options.proxyUrl`
+  - Required
+  - The proxy endpoint to call
+- `options.targetSearchParam`
+  - Optional
+  - The query parameter name that receives the original target URL
+
+**Returns**
+
+- `InkRequestInterceptor`
+  - A reusable interceptor for `configureNetwork()` or `initInk()`
+
 ### `view.bindDomEvents(options?)`
 
 Binds common DOM events to the current `InkView`.
@@ -191,6 +239,9 @@ Fetches an Ink bundle from a remote HTTP VFS service and opens it.
 - `options.headers?: HeadersInit`
   - Optional
   - Extra request headers
+- `options.requestInterceptor?: InkRequestInterceptor`
+  - Optional
+  - Overrides the global interceptor for this VFS load only
 - `options.initialPage?: string | null`
   - Optional
   - Sets the first page to open
@@ -203,6 +254,7 @@ Fetches an Ink bundle from a remote HTTP VFS service and opens it.
 - Fetches the VFS manifest first
 - Fetches each file listed in the manifest
 - Reconstructs the bundle in the browser
+- Applies the request interceptor when one is configured
 - Calls `openBundle()` automatically
 
 **Returns**
@@ -213,6 +265,30 @@ Fetches an Ink bundle from a remote HTTP VFS service and opens it.
   - `manifest: VfsManifest`
   - `files: Map<string, Uint8Array>`
 
+### `initInk(options)`
+
+Initializes the wasm runtime and optionally installs a host networking policy.
+
+**Parameters**
+
+- `options.wasmUrl?: string | URL | Request`
+  - Optional
+  - Custom URL for the wasm binary
+- `options.moduleOrPath?: RequestInfo | URL | Response | BufferSource | WebAssembly.Module`
+  - Optional
+  - Custom wasm module input supported by `wasm-bindgen`
+- `options.requestInterceptor?: InkRequestInterceptor`
+  - Optional
+  - Installs a host request interceptor before Ink networking starts
+- `options.proxyUrl?: string`
+  - Optional
+  - Shorthand for a proxy-based interceptor
+
+**Returns**
+
+- `Promise<{ InkWebView, getInkVersion }>`
+  - Resolves to the wasm bindings
+
 ### `view.startRendering()`
 
 Starts the continuous render loop.

package/dist/README.md

@@ -36,8 +36,7 @@ Before integrating the SDK, make sure you have one of these two inputs:
    - This is a good fit when assets live on the server and the browser fetches
      them on demand.
 
-If you use the VFS flow, the server side usually works together with
-`@yodaos-pkg/ink-vfs-server`.
+If you use the VFS flow, provide your own HTTP VFS endpoint on the server side.
 
 ## Installation
 
@@ -47,10 +46,11 @@ If you use the VFS flow, the server side usually works together with
 npm install @yodaos-pkg/ink
 ```
 
-If you also want to use the VFS flow, install the server package as well:
+If you also want to use the VFS flow, prepare an HTTP endpoint that exposes:
 
-```bash
-npm install @yodaos-pkg/ink-vfs-server
+```text
+GET /apps/:appId/manifest
+GET /apps/:appId/files/:path
 ```
 
 ## Core API
@@ -94,6 +94,54 @@ Creates an `InkView` instance and initializes the wasm runtime internally.
   - Resolves to an `InkView` instance that can then call
     `bindDomEvents()`, `openBundle()`, and `openFromVfs()`
 
+### `configureNetwork(options)`
+
+Configures host-controlled request interception for Ink network traffic.
+
+**Parameters**
+
+- `options.interceptor`
+  - Optional
+  - A function that receives the outgoing request and returns an action
+- `options.proxyUrl`
+  - Optional
+  - A convenience option for rewriting requests through a proxy endpoint
+- `options.targetSearchParam`
+  - Optional
+  - The query parameter name used when `proxyUrl` is provided
+- `options.clear`
+  - Optional
+  - Clears the previously registered interceptor
+
+**What it does**
+
+- Registers a global Ink request interceptor
+- Lets hosts continue, rewrite, or block outgoing requests
+- Mirrors the shape of a WebView-style request interception hook
+
+**Returns**
+
+- `void`
+
+### `createProxyUrlResolver(options)`
+
+Creates a request interceptor that rewrites outgoing requests to a host-managed
+proxy endpoint such as `'/__proxy?url=...'`.
+
+**Parameters**
+
+- `options.proxyUrl`
+  - Required
+  - The proxy endpoint to call
+- `options.targetSearchParam`
+  - Optional
+  - The query parameter name that receives the original target URL
+
+**Returns**
+
+- `InkRequestInterceptor`
+  - A reusable interceptor for `configureNetwork()` or `initInk()`
+
 ### `view.bindDomEvents(options?)`
 
 Binds common DOM events to the current `InkView`.
@@ -191,6 +239,9 @@ Fetches an Ink bundle from a remote HTTP VFS service and opens it.
 - `options.headers?: HeadersInit`
   - Optional
   - Extra request headers
+- `options.requestInterceptor?: InkRequestInterceptor`
+  - Optional
+  - Overrides the global interceptor for this VFS load only
 - `options.initialPage?: string | null`
   - Optional
   - Sets the first page to open
@@ -203,6 +254,7 @@ Fetches an Ink bundle from a remote HTTP VFS service and opens it.
 - Fetches the VFS manifest first
 - Fetches each file listed in the manifest
 - Reconstructs the bundle in the browser
+- Applies the request interceptor when one is configured
 - Calls `openBundle()` automatically
 
 **Returns**
@@ -213,6 +265,30 @@ Fetches an Ink bundle from a remote HTTP VFS service and opens it.
   - `manifest: VfsManifest`
   - `files: Map<string, Uint8Array>`
 
+### `initInk(options)`
+
+Initializes the wasm runtime and optionally installs a host networking policy.
+
+**Parameters**
+
+- `options.wasmUrl?: string | URL | Request`
+  - Optional
+  - Custom URL for the wasm binary
+- `options.moduleOrPath?: RequestInfo | URL | Response | BufferSource | WebAssembly.Module`
+  - Optional
+  - Custom wasm module input supported by `wasm-bindgen`
+- `options.requestInterceptor?: InkRequestInterceptor`
+  - Optional
+  - Installs a host request interceptor before Ink networking starts
+- `options.proxyUrl?: string`
+  - Optional
+  - Shorthand for a proxy-based interceptor
+
+**Returns**
+
+- `Promise<{ InkWebView, getInkVersion }>`
+  - Resolves to the wasm bindings
+
 ### `view.startRendering()`
 
 Starts the continuous render loop.

package/dist/env.js

@@ -2,11 +2,167 @@ let wasmExports = null;
 const allocationSizes = new Map();
 const textDecoder = new TextDecoder('utf-8', { fatal: false });
 const textEncoder = new TextEncoder();
+let inkRequestInterceptor = null;
 
 export function __setWasmInstance(exports) {
   wasmExports = exports;
 }
 
+function ensureFetchImplementation(fetchImpl) {
+  const resolved = fetchImpl || globalThis.fetch;
+  if (typeof resolved !== 'function') {
+    throw new Error('A fetch implementation is required for Ink networking.');
+  }
+  return resolved;
+}
+
+function headersToObject(headersLike) {
+  if (!headersLike) {
+    return {};
+  }
+  if (typeof Headers !== 'undefined' && headersLike instanceof Headers) {
+    const result = {};
+    for (const [name, value] of headersLike.entries()) {
+      result[name] = value;
+    }
+    return result;
+  }
+  if (Array.isArray(headersLike)) {
+    const result = {};
+    for (const entry of headersLike) {
+      if (!Array.isArray(entry) || entry.length < 2) {
+        continue;
+      }
+      result[String(entry[0])] = String(entry[1]);
+    }
+    return result;
+  }
+  if (headersLike && typeof headersLike === 'object') {
+    return Object.fromEntries(
+      Object.entries(headersLike).map(([name, value]) => [name, Array.isArray(value) ? value.join(', ') : String(value)]),
+    );
+  }
+  return {};
+}
+
+function cloneBody(body) {
+  if (body == null) {
+    return null;
+  }
+  if (typeof body === 'string') {
+    return body;
+  }
+  if (body instanceof Uint8Array) {
+    return new Uint8Array(body);
+  }
+  if (ArrayBuffer.isView(body)) {
+    return new Uint8Array(body.buffer.slice(body.byteOffset, body.byteOffset + body.byteLength));
+  }
+  if (body instanceof ArrayBuffer) {
+    return body.slice(0);
+  }
+  return body;
+}
+
+function normalizeRequest(input, init = {}, metadata = {}) {
+  const url = typeof input === 'string' ? input : String(input);
+  return {
+    url,
+    method: String(init.method || 'GET').toUpperCase(),
+    headers: headersToObject(init.headers),
+    body: cloneBody(init.body),
+    metadata: metadata && typeof metadata === 'object' ? { ...metadata } : {},
+  };
+}
+
+function normalizeInterceptorResult(request, result) {
+  if (result == null || result === false) {
+    return {
+      url: request.url,
+      init: {
+        method: request.method,
+        headers: request.headers,
+        body: request.body,
+      },
+    };
+  }
+
+  if (typeof result !== 'object') {
+    throw new TypeError('Ink request interceptor must return an object, null, or undefined.');
+  }
+
+  const action = result.action || 'rewrite';
+  if (action === 'continue') {
+    return {
+      url: request.url,
+      init: {
+        method: request.method,
+        headers: request.headers,
+        body: request.body,
+      },
+    };
+  }
+
+  if (action === 'block') {
+    throw new Error(result.reason || `Ink request blocked: ${request.url}`);
+  }
+
+  if (action !== 'rewrite') {
+    throw new Error(`Unsupported Ink request interceptor action: ${action}`);
+  }
+
+  return {
+    url: typeof result.url === 'string' && result.url ? result.url : request.url,
+    init: {
+      method: typeof result.method === 'string' && result.method ? result.method : request.method,
+      headers: result.headers ? headersToObject(result.headers) : request.headers,
+      body: Object.prototype.hasOwnProperty.call(result, 'body') ? result.body : request.body,
+    },
+  };
+}
+
+async function resolveInkFetchRequest(input, init = {}, metadata = {}, interceptorOverride = null) {
+  const request = normalizeRequest(input, init, metadata);
+  const interceptor = interceptorOverride || inkRequestInterceptor;
+  if (!interceptor) {
+    return {
+      url: request.url,
+      init: {
+        method: request.method,
+        headers: request.headers,
+        body: request.body,
+      },
+    };
+  }
+  const result = await interceptor(request);
+  return normalizeInterceptorResult(request, result);
+}
+
+export function setInkRequestInterceptor(interceptor) {
+  if (interceptor != null && typeof interceptor !== 'function') {
+    throw new TypeError('Ink request interceptor must be a function, null, or undefined.');
+  }
+  inkRequestInterceptor = interceptor || null;
+}
+
+export function clearInkRequestInterceptor() {
+  inkRequestInterceptor = null;
+}
+
+export async function __inkFetch(input, init, metadata) {
+  const resolved = await resolveInkFetchRequest(input, init, metadata);
+  const fetchImpl = ensureFetchImplementation();
+  return fetchImpl(resolved.url, resolved.init);
+}
+
+export async function fetchWithInkRequestInterceptor(input, init = {}, options = {}) {
+  const resolved = await resolveInkFetchRequest(input, init, options.metadata, options.interceptor || null);
+  const fetchImpl = ensureFetchImplementation(options.fetch);
+  return fetchImpl(resolved.url, resolved.init);
+}
+
+globalThis.__inkFetch = __inkFetch;
+
 function requireWasm() {
   if (!wasmExports) {
     throw new Error('Wasm exports are not initialized');

package/dist/index.d.ts

@@ -12,6 +12,9 @@ export type BundleFiles =
 export interface InitInkOptions {
   wasmUrl?: string | URL | Request;
   moduleOrPath?: RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+  proxyUrl?: string;
+  targetSearchParam?: string;
+  requestInterceptor?: InkRequestInterceptor;
 }
 
 export interface CreateInkViewOptions {
@@ -35,6 +38,7 @@ export interface LoadBundleFromVfsOptions {
   fetch?: typeof globalThis.fetch;
   signal?: AbortSignal;
   headers?: HeadersInit;
+  requestInterceptor?: InkRequestInterceptor;
 }
 
 export interface OpenFromVfsOptions extends LoadBundleFromVfsOptions {
@@ -42,6 +46,39 @@ export interface OpenFromVfsOptions extends LoadBundleFromVfsOptions {
   query?: string | Record<string, unknown> | null;
 }
 
+export interface InkInterceptedRequest {
+  url: string;
+  method: string;
+  headers: Record<string, string>;
+  body: BodyInit | ArrayBuffer | ArrayBufferView | Uint8Array | null;
+  metadata: Record<string, unknown>;
+}
+
+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>;
+
+export interface ConfigureNetworkOptions {
+  proxyUrl?: string;
+  targetSearchParam?: string;
+  interceptor?: InkRequestInterceptor;
+  clear?: boolean;
+}
+
 export interface VfsManifestEntry {
   path: string;
   size?: number;
@@ -78,6 +115,17 @@ export declare function normalizeBundleFiles(files: BundleFiles): Map<string, Ui
 
 export declare function serializeQuery(query: string | Record<string, unknown> | null | undefined): string | null;
 
+export declare function createProxyUrlResolver(options: {
+  proxyUrl: string;
+  targetSearchParam?: string;
+}): InkRequestInterceptor;
+
+export declare function setInkRequestInterceptor(interceptor: InkRequestInterceptor | null | undefined): void;
+
+export declare function clearInkRequestInterceptor(): void;
+
+export declare function configureNetwork(options?: ConfigureNetworkOptions): void;
+
 export declare function createVfsUrls(input: {
   baseUrl: string;
   appId: string;
@@ -112,4 +160,8 @@ 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

@@ -2,6 +2,11 @@ import initInkWasm, {
   InkWebView as RawInkWebView,
   get_version as getInkVersionFromWasm,
 } from './pkg/ink_web.js';
+import {
+  clearInkRequestInterceptor as clearInkRequestInterceptorBridge,
+  fetchWithInkRequestInterceptor,
+  setInkRequestInterceptor as setInkRequestInterceptorBridge,
+} from './env.js';
 
 let bindingsPromise;
 
@@ -97,6 +102,51 @@ export function serializeQuery(query) {
   return JSON.stringify(query);
 }
 
+export function createProxyUrlResolver({ proxyUrl, targetSearchParam = 'url' }) {
+  if (typeof proxyUrl !== 'string' || !proxyUrl.trim()) {
+    throw new Error('`proxyUrl` must be a non-empty string.');
+  }
+  if (typeof targetSearchParam !== 'string' || !targetSearchParam.trim()) {
+    throw new Error('`targetSearchParam` must be a non-empty string.');
+  }
+
+  const normalizedProxyUrl = proxyUrl.trim();
+  const normalizedTargetSearchParam = targetSearchParam.trim();
+  return (request) => {
+    const target = new URL(normalizedProxyUrl, globalThis.location?.href || 'http://localhost');
+    target.searchParams.set(normalizedTargetSearchParam, request.url);
+    return {
+      action: 'rewrite',
+      url: target.toString(),
+      method: request.method,
+      headers: request.headers,
+      body: request.body,
+    };
+  };
+}
+
+export function setInkRequestInterceptor(interceptor) {
+  setInkRequestInterceptorBridge(interceptor);
+}
+
+export function clearInkRequestInterceptor() {
+  clearInkRequestInterceptorBridge();
+}
+
+export function configureNetwork(options = {}) {
+  if (options.interceptor) {
+    setInkRequestInterceptor(options.interceptor);
+    return;
+  }
+  if (options.proxyUrl) {
+    setInkRequestInterceptor(createProxyUrlResolver(options));
+    return;
+  }
+  if (options.clear) {
+    clearInkRequestInterceptor();
+  }
+}
+
 async function buildHttpError(response, bodyReader = (res) => res.text()) {
   let details = response.statusText;
   try {
@@ -137,11 +187,21 @@ export async function loadBundleFromVfs({
   fetch: fetchImpl,
   signal,
   headers,
+  requestInterceptor,
 }) {
   const resolvedFetch = ensureFetch(fetchImpl);
+  const wrappedFetch = async (url, init) =>
+    fetchWithInkRequestInterceptor(url, init, {
+      fetch: resolvedFetch,
+      interceptor: requestInterceptor || null,
+      metadata: {
+        kind: 'vfs',
+        appId,
+      },
+    });
   const { manifestUrl, fileUrl } = createVfsUrls({ baseUrl, appId });
 
-  const manifestResponse = await resolvedFetch(manifestUrl, {
+  const manifestResponse = await wrappedFetch(manifestUrl, {
     method: 'GET',
     headers,
     signal,
@@ -162,7 +222,7 @@ export async function loadBundleFromVfs({
         throw new Error('Each VFS manifest entry must include a non-empty `path`.');
       }
 
-      const response = await resolvedFetch(fileUrl(entry.path), {
+      const response = await wrappedFetch(fileUrl(entry.path), {
         method: 'GET',
         headers,
         signal,
@@ -217,6 +277,12 @@ function ensureAnimationFrameApi() {
 }
 
 export async function initInk(options = {}) {
+  if (options.requestInterceptor) {
+    setInkRequestInterceptor(options.requestInterceptor);
+  } else if (options.proxyUrl) {
+    setInkRequestInterceptor(createProxyUrlResolver(options));
+  }
+
   if (!bindingsPromise) {
     const initInput = options.wasmUrl || options.moduleOrPath || new URL('./pkg/ink_web_bg.wasm', import.meta.url);
     bindingsPromise = initInkWasm(initInput).then(() => ({
@@ -377,13 +443,23 @@ export class InkView {
     return this;
   }
 
-  async openFromVfs({ appId, baseUrl, initialPage = null, query = null, fetch, signal, headers }) {
+  async openFromVfs({
+    appId,
+    baseUrl,
+    initialPage = null,
+    query = null,
+    fetch,
+    signal,
+    headers,
+    requestInterceptor,
+  }) {
     const bundle = await loadBundleFromVfs({
       appId,
       baseUrl,
       fetch,
       signal,
       headers,
+      requestInterceptor,
     });
     this.openBundle({
       appId: bundle.appId,
@@ -472,5 +548,9 @@ export function createFrameworkBindings() {
     ensureLeadingSlash,
     initInk,
     createInkView,
+    configureNetwork,
+    setInkRequestInterceptor,
+    clearInkRequestInterceptor,
+    createProxyUrlResolver,
   };
 }

package/dist/pkg/README.md

@@ -17,7 +17,7 @@ This package compiles the Ink engine into Wasm, enabling it to run in modern web
 ./build.sh
 ```
 
-2. Start the bundled Node static server and proxy:
+2. Start the bundled Node static server:
 
 ```bash
 npm run dev --prefix playground
@@ -29,6 +29,6 @@ npm run dev --prefix playground
 http://localhost:8080
 ```
 
-The local server also exposes a same-origin `/__proxy` endpoint for external HTTP resources so
-the demo can load remote images and other browser-fetched assets without direct cross-origin
-requests from the page.
+The playground host configures a same-origin `/__proxy` interceptor example for
+external HTTP resources. This proxy behavior is no longer hard-coded inside
+`ink-web`; hosts now opt into request interception explicitly from the SDK side.

package/dist/pkg/ink_web.d.ts

@@ -41,11 +41,11 @@ export interface InitOutput {
     readonly inkwebview_render: (a: number, b: number) => void;
     readonly inkwebview_resize: (a: number, b: number, c: number, d: number) => void;
     readonly main: () => void;
-    readonly __wasm_bindgen_func_elem_8675: (a: number, b: number) => void;
-    readonly __wasm_bindgen_func_elem_12871: (a: number, b: number) => void;
-    readonly __wasm_bindgen_func_elem_8855: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_12872: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_8856: (a: number, b: number) => void;
+    readonly __wasm_bindgen_func_elem_8655: (a: number, b: number) => void;
+    readonly __wasm_bindgen_func_elem_12872: (a: number, b: number) => void;
+    readonly __wasm_bindgen_func_elem_8822: (a: number, b: number, c: number) => void;
+    readonly __wasm_bindgen_func_elem_12873: (a: number, b: number, c: number) => void;
+    readonly __wasm_bindgen_func_elem_8821: (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/ink_web.js

@@ -314,6 +314,10 @@ function __wbg_get_imports() {
             const ret = getObject(arg0).call(getObject(arg1));
             return addHeapObject(ret);
         }, arguments); },
+        __wbg_call_e8c868596c950cf6: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3), getObject(arg4));
+            return addHeapObject(ret);
+        }, arguments); },
         __wbg_clearRect_1eed255045515c55: function(arg0, arg1, arg2, arg3, arg4) {
             getObject(arg0).clearRect(arg1, arg2, arg3, arg4);
         },
@@ -433,10 +437,6 @@ function __wbg_get_imports() {
         __wbg_error_9a7fe3f932034cde: function(arg0) {
             console.error(getObject(arg0));
         },
-        __wbg_fetch_7f864e6b0cbd00ea: function(arg0, arg1, arg2, arg3) {
-            const ret = getObject(arg0).fetch(getStringFromWasm0(arg1, arg2), getObject(arg3));
-            return addHeapObject(ret);
-        },
         __wbg_fillRect_d44afec47e3a3fab: function(arg0, arg1, arg2, arg3, arg4) {
             getObject(arg0).fillRect(arg1, arg2, arg3, arg4);
         },
@@ -943,28 +943,28 @@ function __wbg_get_imports() {
             return ret;
         },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 2341, function: Function { arguments: [NamedExternref("CloseEvent")], shim_idx: 2298, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_8675, __wasm_bindgen_func_elem_8855);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 2276, function: Function { arguments: [NamedExternref("CloseEvent")], shim_idx: 2278, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_8655, __wasm_bindgen_func_elem_8822);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 2341, function: Function { arguments: [NamedExternref("Event")], shim_idx: 2298, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_8675, __wasm_bindgen_func_elem_8855);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 2276, function: Function { arguments: [NamedExternref("Event")], shim_idx: 2278, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_8655, __wasm_bindgen_func_elem_8822);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000003: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 2341, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 2298, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_8675, __wasm_bindgen_func_elem_8855);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 2276, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 2278, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_8655, __wasm_bindgen_func_elem_8822);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000004: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { dtor_idx: 2341, function: Function { arguments: [], shim_idx: 2344, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_8675, __wasm_bindgen_func_elem_8856);
+            // Cast intrinsic for `Closure(Closure { dtor_idx: 2276, function: Function { arguments: [], shim_idx: 2280, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_8655, __wasm_bindgen_func_elem_8821);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000005: function(arg0, arg1) {
             // Cast intrinsic for `Closure(Closure { dtor_idx: 3267, function: Function { arguments: [Externref], shim_idx: 3268, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_12871, __wasm_bindgen_func_elem_12872);
+            const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_12872, __wasm_bindgen_func_elem_12873);
             return addHeapObject(ret);
         },
         __wbindgen_cast_0000000000000006: function(arg0) {
@@ -1019,16 +1019,16 @@ function __wbg_get_imports() {
     };
 }
 
-function __wasm_bindgen_func_elem_8856(arg0, arg1) {
-    wasm.__wasm_bindgen_func_elem_8856(arg0, arg1);
+function __wasm_bindgen_func_elem_8821(arg0, arg1) {
+    wasm.__wasm_bindgen_func_elem_8821(arg0, arg1);
 }
 
-function __wasm_bindgen_func_elem_8855(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_8855(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_8822(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_8822(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wasm_bindgen_func_elem_12872(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_12872(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_12873(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_12873(arg0, arg1, addHeapObject(arg2));
 }
 
 

package/dist/pkg/ink_web_bg.wasm.d.ts

@@ -16,11 +16,11 @@ export const inkwebview_openBundle: (a: number, b: number, c: number, d: number,
 export const inkwebview_render: (a: number, b: number) => void;
 export const inkwebview_resize: (a: number, b: number, c: number, d: number) => void;
 export const main: () => void;
-export const __wasm_bindgen_func_elem_8675: (a: number, b: number) => void;
-export const __wasm_bindgen_func_elem_12871: (a: number, b: number) => void;
-export const __wasm_bindgen_func_elem_8855: (a: number, b: number, c: number) => void;
-export const __wasm_bindgen_func_elem_12872: (a: number, b: number, c: number) => void;
-export const __wasm_bindgen_func_elem_8856: (a: number, b: number) => void;
+export const __wasm_bindgen_func_elem_8655: (a: number, b: number) => void;
+export const __wasm_bindgen_func_elem_12872: (a: number, b: number) => void;
+export const __wasm_bindgen_func_elem_8822: (a: number, b: number, c: number) => void;
+export const __wasm_bindgen_func_elem_12873: (a: number, b: number, c: number) => void;
+export const __wasm_bindgen_func_elem_8821: (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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yodaos-pkg/ink",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Ink Web SDK for browser rendering and VFS-backed app loading",
   "type": "module",
   "main": "dist/index.js",