What are the four WebAssembly external kinds?

A module can import and export functions (func), tables (table), linear memories (memory) and globals (global). Each import names a two-level module/name pair, and each export names a single field. These are the only externally-visible entity kinds.

How does a JavaScript import object map to module imports?

The import object is a nested record keyed first by the import's module string and then by its name string. So an import of (import "env" "log" (func ...)) is satisfied by importObject.env.log. The value must match the declared kind: a JS function, WebAssembly.Memory, Table or Global.

Can an imported global be mutable?

Yes. A global declared (global (mut i32)) is mutable and must be provided as a WebAssembly.Global created with mutable: true. An immutable imported global can be supplied as a plain number for i32/f32/f64 or a BigInt for i64.

What do memory and table import limits mean?

Both declare a minimum and optional maximum size. Memory is measured in 64KiB pages; a table in elements. The supplied WebAssembly.Memory or Table must satisfy the declared minimum and not exceed any declared maximum, or instantiation throws a LinkError.

Does this tool run any WebAssembly?

No. It is a static, offline reference of import/export descriptor syntax. Nothing is compiled, instantiated or sent over the network.

WebAssembly Import/Export Reference

Email me this result

Get this tool's output sent to your inbox, plus one useful tool a week. No spam, unsubscribe any time.

WebAssembly module boundaries

A WebAssembly module communicates with its host through two flat lists: imports it requires and exports it offers. Both reference one of four external kinds — func, table, memory or global. This reference shows the WebAssembly text (WAT) syntax for each and the matching JavaScript binding used by WebAssembly.instantiate.

How it works

Every import carries a two-level name: a module string and a field string. At instantiation the host supplies an import object — a nested record — and the linker matches (import "mod" "name" ...) to importObject.mod.name:

(module
  (import "env" "log" (func $log (param i32)))
  (import "env" "mem" (memory 1))
  (global $g (export "counter") (mut i32) (i32.const 0))
  (func (export "run") ... ))

const importObject = {
  env: {
    log: (n) => console.log(n),
    mem: new WebAssembly.Memory({ initial: 1 }),
  },
};
const { instance } = await WebAssembly.instantiate(bytes, importObject);
instance.exports.run();

Exports appear on instance.exports after instantiation. The supplied import value must match the declared kind and limits, or a LinkError is thrown.

Tips and notes

Memory size is in 64 KiB pages; a (memory 1) is exactly 65536 bytes.
i64 globals/params surface in JS as BigInt, not Number.
Mutable globals need WebAssembly.Global({ mutable: true }, ...).
A table’s element type is funcref (or externref with reference types).