space-data-module-sdk 0.6.0 → 0.6.1

package/src/host/nodeHost.js

@@ -63,6 +63,7 @@ export const NodeHostSupportedCapabilities = Object.freeze([
   "crypto_decrypt",
   "crypto_key_agreement",
   "crypto_kdf",
+  "wallet_sign",
   "process_exec",
 ]);
 
@@ -93,9 +94,13 @@ export const NodeHostSupportedOperations = Object.freeze([
   "udp.request",
   "tls.request",
   "ipfs.invoke",
+  "ipfs.add",
+  "ipfs.cat",
   "protocol_handle.register",
   "protocol_handle.unregister",
   "protocol_dial.dial",
+  "protocol.request",
+  "keyslot.get",
   "exec.execFile",
   "context.get",
   "context.set",
@@ -160,6 +165,34 @@ function normalizeGrantedCapabilities(options) {
   return normalized;
 }
 
+function resolveCapabilityAdapters(options = {}) {
+  const adapters =
+    options.capabilityAdapters && typeof options.capabilityAdapters === "object"
+      ? options.capabilityAdapters
+      : {};
+  return {
+    filesystem: options.filesystem ?? adapters.filesystem ?? null,
+    network: options.network ?? adapters.network ?? null,
+    ipfs: options.ipfs ?? adapters.ipfs ?? null,
+    walletSign:
+      options.walletSign ??
+      adapters.walletSign ??
+      adapters.wallet_sign ??
+      adapters.keyslot ??
+      null,
+    protocolHandle:
+      options.protocolHandle ??
+      adapters.protocolHandle ??
+      adapters.protocol_handle ??
+      null,
+    protocolDial:
+      options.protocolDial ??
+      adapters.protocolDial ??
+      adapters.protocol_dial ??
+      null,
+  };
+}
+
 function normalizeAllowedOrigins(origins) {
   if (origins === undefined || origins === null) {
     return null;
@@ -1445,10 +1478,13 @@ export class NodeHost {
     );
     this.fetch = options.fetch ?? globalThis.fetch;
     this.WebSocket = options.WebSocket ?? globalThis.WebSocket;
-    this._networkAdapter = options.network ?? null;
-    this._ipfsAdapter = options.ipfs ?? null;
-    this._protocolHandleAdapter = options.protocolHandle ?? null;
-    this._protocolDialAdapter = options.protocolDial ?? null;
+    const capabilityAdapters = resolveCapabilityAdapters(options);
+    this._filesystemAdapter = capabilityAdapters.filesystem;
+    this._networkAdapter = capabilityAdapters.network;
+    this._ipfsAdapter = capabilityAdapters.ipfs;
+    this._walletSignAdapter = capabilityAdapters.walletSign;
+    this._protocolHandleAdapter = capabilityAdapters.protocolHandle;
+    this._protocolDialAdapter = capabilityAdapters.protocolDial;
     if (typeof this.fetch !== "function") {
       throw new TypeError(
         "A fetch implementation is required to create a Node host.",
@@ -1607,6 +1643,12 @@ export class NodeHost {
         this.#withCapability("network", "network.request", async () => {
           const transport = normalizeNetworkTransport(params);
           const request = params.request ?? params;
+          if (this._networkAdapter) {
+            return invokeAdapterMethod(this._networkAdapter, "request", {
+              ...request,
+              transport,
+            }, "network");
+          }
           switch (transport) {
             case "http":
               return this.http.request(request);
@@ -1623,12 +1665,6 @@ export class NodeHost {
             case "tls":
               return this.tls.request(request);
             default:
-              if (this._networkAdapter) {
-                return invokeAdapterMethod(this._networkAdapter, "request", {
-                  ...request,
-                  transport,
-                }, "network");
-              }
               throw new Error(
                 `Node host does not support network transport "${transport}".`,
               );
@@ -1636,6 +1672,87 @@ export class NodeHost {
         }),
     });
 
+    const builtinFilesystem = {
+      resolvePath: (targetPath) => this.#resolveFilesystemPath(targetPath),
+      readFile: async (targetPath, options = {}) => {
+        const resolvedPath = this.#resolveFilesystemPath(targetPath);
+        const file = await readFile(resolvedPath);
+        if (options.encoding) {
+          return file.toString(options.encoding);
+        }
+        return new Uint8Array(file);
+      },
+      writeFile: async (targetPath, value, options = {}) => {
+        const resolvedPath = this.#resolveFilesystemPath(targetPath);
+        await mkdir(path.dirname(resolvedPath), { recursive: true });
+        await writeFile(
+          resolvedPath,
+          typeof value === "string" ? value : Buffer.from(toUint8Array(value)),
+          options.encoding && typeof value === "string" ? options.encoding : undefined,
+        );
+        return { path: resolvedPath };
+      },
+      appendFile: async (targetPath, value, options = {}) => {
+        const resolvedPath = this.#resolveFilesystemPath(targetPath);
+        await mkdir(path.dirname(resolvedPath), { recursive: true });
+        const existing = await readFile(resolvedPath).catch((error) => {
+          if (error?.code === "ENOENT") {
+            return Buffer.alloc(0);
+          }
+          throw error;
+        });
+        const nextChunk =
+          typeof value === "string"
+            ? Buffer.from(value, options.encoding ?? "utf8")
+            : Buffer.from(toUint8Array(value));
+        await writeFile(resolvedPath, Buffer.concat([existing, nextChunk]));
+        return { path: resolvedPath };
+      },
+      deleteFile: async (targetPath) => {
+        const resolvedPath = this.#resolveFilesystemPath(targetPath);
+        await rm(resolvedPath, { force: true });
+        return { path: resolvedPath };
+      },
+      mkdir: async (targetPath, options = {}) => {
+        const resolvedPath = this.#resolveFilesystemPath(targetPath);
+        await mkdir(resolvedPath, {
+          recursive: options.recursive ?? true,
+        });
+        return { path: resolvedPath };
+      },
+      readdir: async (targetPath = ".") => {
+        const resolvedPath = this.#resolveFilesystemPath(targetPath);
+        const entries = await readdir(resolvedPath, { withFileTypes: true });
+        return entries
+          .map((entry) => ({
+            name: entry.name,
+            isFile: entry.isFile(),
+            isDirectory: entry.isDirectory(),
+          }))
+          .sort((left, right) => left.name.localeCompare(right.name));
+      },
+      stat: async (targetPath) => {
+        const resolvedPath = this.#resolveFilesystemPath(targetPath);
+        const metadata = await stat(resolvedPath);
+        return {
+          path: resolvedPath,
+          size: metadata.size,
+          isFile: metadata.isFile(),
+          isDirectory: metadata.isDirectory(),
+          ctimeMs: metadata.ctimeMs,
+          mtimeMs: metadata.mtimeMs,
+        };
+      },
+      rename: async (fromPath, toPath) => {
+        const resolvedFrom = this.#resolveFilesystemPath(fromPath);
+        const resolvedTo = this.#resolveFilesystemPath(toPath);
+        await mkdir(path.dirname(resolvedTo), { recursive: true });
+        await rename(resolvedFrom, resolvedTo);
+        return { from: resolvedFrom, to: resolvedTo };
+      },
+    };
+    const filesystem = this._filesystemAdapter ?? builtinFilesystem;
+
     this.mqtt = Object.freeze({
       publish: async (mqttOptions = {}) =>
         this.#withCapability("mqtt", "mqtt.publish", async () => {
@@ -1687,91 +1804,39 @@ export class NodeHost {
     this.filesystem = Object.freeze({
       resolvePath: (targetPath) =>
         this.#withCapability("filesystem", "filesystem.resolvePath", () =>
-          this.#resolveFilesystemPath(targetPath),
+          filesystem.resolvePath(targetPath),
         ),
       readFile: async (targetPath, options = {}) =>
         this.#withCapability("filesystem", "filesystem.readFile", async () => {
-          const resolvedPath = this.#resolveFilesystemPath(targetPath);
-          const file = await readFile(resolvedPath);
-          if (options.encoding) {
-            return file.toString(options.encoding);
-          }
-          return new Uint8Array(file);
+          return filesystem.readFile(targetPath, options);
         }),
       writeFile: async (targetPath, value, options = {}) =>
         this.#withCapability("filesystem", "filesystem.writeFile", async () => {
-          const resolvedPath = this.#resolveFilesystemPath(targetPath);
-          await mkdir(path.dirname(resolvedPath), { recursive: true });
-          await writeFile(
-            resolvedPath,
-            typeof value === "string" ? value : Buffer.from(toUint8Array(value)),
-            options.encoding && typeof value === "string" ? options.encoding : undefined,
-          );
-          return { path: resolvedPath };
+          return filesystem.writeFile(targetPath, value, options);
         }),
       appendFile: async (targetPath, value, options = {}) =>
         this.#withCapability("filesystem", "filesystem.appendFile", async () => {
-          const resolvedPath = this.#resolveFilesystemPath(targetPath);
-          await mkdir(path.dirname(resolvedPath), { recursive: true });
-          const existing = await readFile(resolvedPath).catch((error) => {
-            if (error?.code === "ENOENT") {
-              return Buffer.alloc(0);
-            }
-            throw error;
-          });
-          const nextChunk =
-            typeof value === "string"
-              ? Buffer.from(value, options.encoding ?? "utf8")
-              : Buffer.from(toUint8Array(value));
-          await writeFile(resolvedPath, Buffer.concat([existing, nextChunk]));
-          return { path: resolvedPath };
+          return filesystem.appendFile(targetPath, value, options);
         }),
       deleteFile: async (targetPath) =>
         this.#withCapability("filesystem", "filesystem.deleteFile", async () => {
-          const resolvedPath = this.#resolveFilesystemPath(targetPath);
-          await rm(resolvedPath, { force: true });
-          return { path: resolvedPath };
+          return filesystem.deleteFile(targetPath);
         }),
       mkdir: async (targetPath, options = {}) =>
         this.#withCapability("filesystem", "filesystem.mkdir", async () => {
-          const resolvedPath = this.#resolveFilesystemPath(targetPath);
-          await mkdir(resolvedPath, {
-            recursive: options.recursive ?? true,
-          });
-          return { path: resolvedPath };
+          return filesystem.mkdir(targetPath, options);
         }),
       readdir: async (targetPath = ".") =>
         this.#withCapability("filesystem", "filesystem.readdir", async () => {
-          const resolvedPath = this.#resolveFilesystemPath(targetPath);
-          const entries = await readdir(resolvedPath, { withFileTypes: true });
-          return entries
-            .map((entry) => ({
-              name: entry.name,
-              isFile: entry.isFile(),
-              isDirectory: entry.isDirectory(),
-            }))
-            .sort((left, right) => left.name.localeCompare(right.name));
+          return filesystem.readdir(targetPath);
         }),
       stat: async (targetPath) =>
         this.#withCapability("filesystem", "filesystem.stat", async () => {
-          const resolvedPath = this.#resolveFilesystemPath(targetPath);
-          const metadata = await stat(resolvedPath);
-          return {
-            path: resolvedPath,
-            size: metadata.size,
-            isFile: metadata.isFile(),
-            isDirectory: metadata.isDirectory(),
-            ctimeMs: metadata.ctimeMs,
-            mtimeMs: metadata.mtimeMs,
-          };
+          return filesystem.stat(targetPath);
         }),
       rename: async (fromPath, toPath) =>
         this.#withCapability("filesystem", "filesystem.rename", async () => {
-          const resolvedFrom = this.#resolveFilesystemPath(fromPath);
-          const resolvedTo = this.#resolveFilesystemPath(toPath);
-          await mkdir(path.dirname(resolvedTo), { recursive: true });
-          await rename(resolvedFrom, resolvedTo);
-          return { from: resolvedFrom, to: resolvedTo };
+          return filesystem.rename(fromPath, toPath);
         }),
     });
 
@@ -1921,6 +1986,14 @@ export class NodeHost {
           }
           return invokeAdapterMethod(this._ipfsAdapter, operation, params, "ipfs");
         }),
+      add: async (params = {}) =>
+        this.#withCapability("ipfs", "ipfs.add", async () =>
+          invokeAdapterMethod(this._ipfsAdapter, "add", params, "ipfs"),
+        ),
+      cat: async (params = {}) =>
+        this.#withCapability("ipfs", "ipfs.cat", async () =>
+          invokeAdapterMethod(this._ipfsAdapter, "cat", params, "ipfs"),
+        ),
     });
 
     this.protocolHandle = Object.freeze({
@@ -1960,6 +2033,22 @@ export class NodeHost {
             "protocol_dial",
           ),
         ),
+      request: async (params = {}) =>
+        this.#withCapability("protocol_dial", "protocol.request", async () =>
+          invokeAdapterMethod(
+            this._protocolDialAdapter,
+            "request",
+            params,
+            "protocol_dial",
+          ),
+        ),
+    });
+
+    this.keyslot = Object.freeze({
+      get: async (params = {}) =>
+        this.#withCapability("wallet_sign", "keyslot.get", async () =>
+          invokeAdapterMethod(this._walletSignAdapter, "get", params, "wallet_sign"),
+        ),
     });
   }
 
@@ -2100,12 +2189,20 @@ export class NodeHost {
         return this.tls.request(params);
       case "ipfs.invoke":
         return this.ipfs.invoke(params);
+      case "ipfs.add":
+        return this.ipfs.add(params);
+      case "ipfs.cat":
+        return this.ipfs.cat(params);
       case "protocol_handle.register":
         return this.protocolHandle.register(params);
       case "protocol_handle.unregister":
         return this.protocolHandle.unregister(params);
       case "protocol_dial.dial":
         return this.protocolDial.dial(params);
+      case "protocol.request":
+        return this.protocolDial.request(params);
+      case "keyslot.get":
+        return this.keyslot.get(params);
       case "exec.execFile":
         return this.exec.execFile(params);
       case "context.get":

package/src/index.d.ts

@@ -409,6 +409,18 @@ export interface RuntimeHost {
   rows: FlatSqlRuntimeStore;
   regions: RuntimeRegionStore;
   moduleRegistry: RuntimeModuleRegistry;
+  listCapabilities(): string[];
+  listSupportedCapabilities(): string[];
+  listOperations(): string[];
+  hasCapability(capability: string): boolean;
+  getCapability(capability: string): Record<string, (...args: any[]) => unknown> | null;
+  registerCapability(
+    capability: string,
+    adapter: Record<string, (...args: any[]) => unknown>,
+  ): Record<string, (...args: any[]) => unknown>;
+  unregisterCapability(capability: string): boolean;
+  invokeCapability(operation: string, params?: Record<string, any>): Promise<unknown>;
+  invoke(operation: string, params?: Record<string, any>): Promise<unknown>;
 }
 
 export function createFlatBufferStreamIngestor(options?: {
@@ -1117,13 +1129,21 @@ export interface BrowserEdgeShims {
     now(): number;
     timeOrigin: number;
   };
+  network?: Record<string, (...args: any[]) => unknown> | null;
+  ipfs?: Record<string, (...args: any[]) => unknown> | null;
+  walletSign?: Record<string, (...args: any[]) => unknown> | null;
+  protocolHandle?: Record<string, (...args: any[]) => unknown> | null;
+  protocolDial?: Record<string, (...args: any[]) => unknown> | null;
   filesystem?: BrowserFilesystemShim;
+  filesystemRoot?: string;
+  capabilityAdapters?: Record<string, Record<string, (...args: any[]) => unknown>>;
 }
 
 export interface BrowserHostOptions {
   capabilities?: string[];
   edgeShims?: BrowserEdgeShims;
   contextStore?: Map<string, Map<string, unknown>>;
+  wasmWallet?: unknown;
   fetch?: (...args: any[]) => Promise<any>;
   WebSocket?: any;
   crypto?: any;
@@ -1133,6 +1153,12 @@ export interface BrowserHostOptions {
   };
   filesystem?: BrowserFilesystemShim;
   filesystemRoot?: string;
+  network?: Record<string, (...args: any[]) => unknown> | null;
+  ipfs?: Record<string, (...args: any[]) => unknown> | null;
+  walletSign?: Record<string, (...args: any[]) => unknown> | null;
+  protocolHandle?: Record<string, (...args: any[]) => unknown> | null;
+  protocolDial?: Record<string, (...args: any[]) => unknown> | null;
+  capabilityAdapters?: Record<string, Record<string, (...args: any[]) => unknown>>;
 }
 
 export interface NodeHostOptions {
@@ -1156,6 +1182,40 @@ export interface NodeHostOptions {
   contextStore?: NodeHostContextStore;
   fetch?: (...args: any[]) => Promise<any>;
   WebSocket?: any;
+  filesystem?: {
+    resolvePath(path: string): string;
+    readFile(
+      path: string,
+      options?: { encoding?: string | null },
+    ): Promise<string | Uint8Array>;
+    writeFile(
+      path: string,
+      value: Uint8Array | ArrayBuffer | ArrayBufferView | string,
+      options?: { encoding?: string | null },
+    ): Promise<{ path: string }>;
+    appendFile(
+      path: string,
+      value: Uint8Array | ArrayBuffer | ArrayBufferView | string,
+      options?: { encoding?: string | null },
+    ): Promise<{ path: string }>;
+    deleteFile(path: string): Promise<{ path: string }>;
+    mkdir(
+      path: string,
+      options?: { recursive?: boolean },
+    ): Promise<{ path: string }>;
+    readdir(path?: string): Promise<NodeHostFilesystemEntry[]>;
+    stat(path: string): Promise<NodeHostFilesystemStat>;
+    rename(
+      fromPath: string,
+      toPath: string,
+    ): Promise<{ from: string; to: string }>;
+  } | null;
+  network?: Record<string, (...args: any[]) => unknown> | null;
+  ipfs?: Record<string, (...args: any[]) => unknown> | null;
+  walletSign?: Record<string, (...args: any[]) => unknown> | null;
+  protocolHandle?: Record<string, (...args: any[]) => unknown> | null;
+  protocolDial?: Record<string, (...args: any[]) => unknown> | null;
+  capabilityAdapters?: Record<string, Record<string, (...args: any[]) => unknown>>;
 }
 
 export class HostCapabilityError extends Error {
@@ -1468,16 +1528,51 @@ export class BrowserHost {
   crypto: {
     sha256(data: Uint8Array | ArrayBuffer | ArrayBufferView | string): Promise<Uint8Array>;
     sha512(data: Uint8Array | ArrayBuffer | ArrayBufferView | string): Promise<Uint8Array>;
+    hkdf(options: {
+      ikm: Uint8Array | ArrayBuffer | ArrayBufferView | number[];
+      salt: Uint8Array | ArrayBuffer | ArrayBufferView | number[];
+      info?: Uint8Array | ArrayBuffer | ArrayBufferView | number[];
+      length: number;
+    }): Promise<Uint8Array>;
     aesGcmEncrypt(options: {
       key: Uint8Array | ArrayBuffer | ArrayBufferView;
       plaintext: Uint8Array | ArrayBuffer | ArrayBufferView;
       iv?: Uint8Array | ArrayBuffer | ArrayBufferView;
-    }): Promise<{ ciphertext: Uint8Array; iv: Uint8Array | ArrayBuffer | ArrayBufferView }>;
+      aad?: Uint8Array | ArrayBuffer | ArrayBufferView | number[] | null;
+    }): Promise<{
+      ciphertext: Uint8Array;
+      tag: Uint8Array;
+      iv: Uint8Array | ArrayBuffer | ArrayBufferView;
+    }>;
     aesGcmDecrypt(options: {
       key: Uint8Array | ArrayBuffer | ArrayBufferView;
       ciphertext: Uint8Array | ArrayBuffer | ArrayBufferView;
+      tag: Uint8Array | ArrayBuffer | ArrayBufferView;
       iv: Uint8Array | ArrayBuffer | ArrayBufferView;
+      aad?: Uint8Array | ArrayBuffer | ArrayBufferView | number[] | null;
     }): Promise<Uint8Array>;
+    generateX25519Keypair(): Promise<X25519Keypair>;
+    x25519PublicKey(
+      privateKey: Uint8Array | ArrayBuffer | ArrayBufferView | number[],
+    ): Promise<Uint8Array>;
+    x25519SharedSecret(
+      privateKey: Uint8Array | ArrayBuffer | ArrayBufferView | number[],
+      publicKey: Uint8Array | ArrayBuffer | ArrayBufferView | number[],
+    ): Promise<Uint8Array>;
+    ed25519: {
+      publicKeyFromSeed(
+        seed: Uint8Array | ArrayBuffer | ArrayBufferView | number[],
+      ): Promise<Uint8Array>;
+      sign(
+        message: Uint8Array | ArrayBuffer | ArrayBufferView | number[],
+        seed: Uint8Array | ArrayBuffer | ArrayBufferView | number[],
+      ): Promise<Uint8Array>;
+      verify(
+        message: Uint8Array | ArrayBuffer | ArrayBufferView | number[],
+        signature: Uint8Array | ArrayBuffer | ArrayBufferView | number[],
+        publicKey: Uint8Array | ArrayBuffer | ArrayBufferView | number[],
+      ): Promise<boolean>;
+    };
   };
   filesystem: BrowserFilesystemShim;
   constructor(options?: BrowserHostOptions);
@@ -1576,6 +1671,7 @@ export interface BrowserModuleHarness {
   host: BrowserHost;
   bridge: HostcallBridge | null;
   wasi: BrowserWasiShim;
+  callHost(operation: string, params?: Record<string, any>): Promise<unknown>;
   invokeRaw(
     requestBytes: Uint8Array | ArrayBuffer | ArrayBufferView,
   ): Promise<Uint8Array>;
@@ -1594,7 +1690,7 @@ export interface BrowserModuleHarness {
 export function detectArtifactProfile(wasmModule: WebAssembly.Module): string;
 export function createBrowserModuleHarness(options?: {
   wasmSource: Uint8Array | ArrayBuffer | string | WebAssembly.Module | unknown;
-  host?: BrowserHost;
+  host?: BrowserHost | RuntimeHost | Record<string, unknown>;
   hostOptions?: BrowserHostOptions;
   args?: string[];
   env?: Record<string, string>;
@@ -1665,7 +1761,7 @@ export function createModuleFlatBufferStreamPump(options: {
 }): ModuleFlatBufferStreamPump;
 export function loadModule(options?: {
   wasmSource: Uint8Array | ArrayBuffer | string | WebAssembly.Module | unknown;
-  host?: BrowserHost;
+  host?: BrowserHost | RuntimeHost | Record<string, unknown>;
   hostOptions?: BrowserHostOptions;
   args?: string[];
   env?: Record<string, string | undefined>;

package/src/runtime-host/index.js

@@ -23,6 +23,28 @@ function createCapabilityRegistry(capabilities = {}) {
   return registry;
 }
 
+function listCapabilityOperations(capabilities) {
+  const operations = new Set();
+  for (const [capabilityId, adapter] of capabilities.entries()) {
+    if (!adapter || typeof adapter !== "object") {
+      continue;
+    }
+    const methodIds = Object.keys(adapter).filter(
+      (methodId) => typeof adapter[methodId] === "function" && methodId !== "invoke",
+    );
+    if (methodIds.length > 0) {
+      for (const methodId of methodIds) {
+        operations.add(`${capabilityId}.${methodId}`);
+      }
+      continue;
+    }
+    if (typeof adapter.invoke === "function") {
+      operations.add(`${capabilityId}.invoke`);
+    }
+  }
+  return Array.from(operations).sort();
+}
+
 export function createRuntimeHost(options = {}) {
   const rows = options.rows ?? createFlatSqlRuntimeStore();
   const regions = options.regions ?? createRuntimeRegionStore();
@@ -36,6 +58,15 @@ export function createRuntimeHost(options = {}) {
     listCapabilities() {
       return Array.from(capabilities.keys()).sort();
     },
+    listSupportedCapabilities() {
+      return Array.from(capabilities.keys()).sort();
+    },
+    listOperations() {
+      return listCapabilityOperations(capabilities);
+    },
+    hasCapability(capability) {
+      return capabilities.has(normalizeCapabilityId(capability));
+    },
     getCapability(capability) {
       return capabilities.get(normalizeCapabilityId(capability)) ?? null;
     },
@@ -68,6 +99,9 @@ export function createRuntimeHost(options = {}) {
         `Runtime host capability "${capabilityId}" does not implement "${methodId}" or invoke().`,
       );
     },
+    async invoke(operation, params = {}) {
+      return this.invokeCapability(operation, params);
+    },
   };
 }
 

package/src/testing/browserModuleHarness.js

@@ -14,10 +14,11 @@
 
 import { createBrowserWasiShim, WasiExitError } from "../host/wasiShim.js";
 import { createBrowserHost } from "../host/browserHost.js";
+import { getWasmWallet } from "../utils/wasmCrypto.js";
 import {
   createJsonHostcallBridge,
+  createAsyncHostDispatcher,
   createHostSyncDispatcher,
-  dispatchHostOperation,
   DEFAULT_HOSTCALL_IMPORT_MODULE,
 } from "../host/abi.js";
 import {
@@ -126,8 +127,20 @@ async function instantiateBrowserModule(options = {}) {
  * @param {string} [options.surface] - "direct" or "command" (default: auto-detect).
  */
 export async function createBrowserModuleHarness(options = {}) {
-  const host = options.host ?? createBrowserHost(options.hostOptions);
   const wasmModule = await compileWasmModule(options.wasmSource);
+  const moduleImports = WebAssembly.Module.imports(wasmModule);
+  const needsHostBridge = moduleImports.some(
+    (entry) => entry.module === DEFAULT_HOSTCALL_IMPORT_MODULE,
+  );
+  const hostOptions =
+    !options.host && needsHostBridge && !options.hostOptions?.wasmWallet
+      ? {
+          ...options.hostOptions,
+          wasmWallet: await getWasmWallet(),
+        }
+      : options.hostOptions;
+  const host = options.host ?? createBrowserHost(hostOptions);
+  const dispatchHost = createAsyncHostDispatcher(host);
 
   const profile = detectArtifactProfile(wasmModule);
   const moduleExports = WebAssembly.Module.exports(wasmModule);
@@ -240,7 +253,7 @@ export async function createBrowserModuleHarness(options = {}) {
   }
 
   async function callHost(operation, params = {}) {
-    return dispatchHostOperation(host, operation, params);
+    return dispatchHost(operation, params);
   }
 
   function readManifest() {

package/src/testing/index.d.ts

@@ -335,6 +335,7 @@ export interface BrowserModuleHarness {
     stdout: Uint8Array;
     stderr: Uint8Array;
   };
+  callHost(operation: string, params?: Record<string, any>): Promise<unknown>;
   invokeRaw(
     requestBytes: Uint8Array | ArrayBuffer | ArrayBufferView,
   ): Promise<Uint8Array>;

package/src/testing/index.js

@@ -98,6 +98,7 @@ const CapabilitySurfaceMatrix = Object.freeze({
     notes: [
       "WASI preopens are the preferred cross-runtime filesystem surface.",
       "The sync hostcall ABI currently exposes filesystem.resolvePath only.",
+      "Awaited filesystem reads and writes live on the generic async host boundary shared by NodeHost, BrowserHost, runtime-host capability registries, and harness callHost dispatch.",
     ],
   }),
   pipe: Object.freeze({
@@ -121,7 +122,7 @@ const CapabilitySurfaceMatrix = Object.freeze({
     nodeHostApi: true,
     notes: [
       "The coarse network capability maps to async host-side HTTP/TCP/UDP/TLS/WebSocket services.",
-      "Browser harnesses can await the same capability surface through BrowserHost.invoke().",
+      "Browser and Node harnesses can await the same capability surface through BrowserHost.invoke(), loadModule(...).callHost(...), and createBrowserModuleHarness(...).callHost(...).",
       "Pure WASI guests cannot reach that surface through the current sync hostcall ABI.",
       "WasmEdge provides non-blocking socket-oriented extensions that can serve as the standard server-side max-WASI target.",
     ],
@@ -207,7 +208,7 @@ const CapabilitySurfaceMatrix = Object.freeze({
     syncHostcall: false,
     nodeHostApi: true,
     notes: [
-      "IPFS access is available through async host adapters and browser/module harness dispatch.",
+      "IPFS access is available through the generic async host boundary and browser/module harness dispatch.",
       "Pure WASM guests cannot reach that surface through the current sync hostcall ABI.",
     ],
   }),
@@ -219,7 +220,7 @@ const CapabilitySurfaceMatrix = Object.freeze({
     syncHostcall: false,
     nodeHostApi: true,
     notes: [
-      "Protocol registration is available through async host adapters and browser/module harness dispatch.",
+      "Protocol registration is available through the generic async host boundary and browser/module harness dispatch.",
       "Pure WASM guests cannot reach that surface through the current sync hostcall ABI.",
     ],
   }),
@@ -231,7 +232,7 @@ const CapabilitySurfaceMatrix = Object.freeze({
     syncHostcall: false,
     nodeHostApi: true,
     notes: [
-      "Protocol dialing is available through async host adapters and browser/module harness dispatch.",
+      "Protocol dialing is available through the generic async host boundary and browser/module harness dispatch.",
       "Pure WASM guests cannot reach that surface through the current sync hostcall ABI.",
     ],
   }),