scriptc namespace.
```ts title="counter.ts"
declare function changed(value: number): void;
let count = 0;
export function step(delta: number): number {
count += delta;
changed(count);
return count;
}
```
```json title="counter.json"
{
"profile_format": 1,
"name": "counter",
"entry": "counter.ts",
"emission": "llvm",
"abi": {
"prefix": "counter_",
"init_symbol": "counter_init",
"sink_register_symbol": "counter_sink",
"callback_register_symbol": "counter_callback"
},
"callbacks": [{ "name": "changed", "params": ["f64"], "returns": "void" }],
"exports": [{ "export": "step", "symbol": "counter_step", "params": ["f64"], "returns": "f64" }]
}
```
Build the module:
```console
$ SCRIPTC_TARGET=wasm32-wasi scriptc build --lib --profile counter.json -o counter.wasm
```
Without `-o`, the output is `.scriptc/counter.wasm` beside the profile. The compiler API's `compileLibrary()` returns this path in `archivePath`, as it does for native libraries.
The profile uses the same schema as native library builds. sink\_register\_symbol and callback\_register\_symbol name native registration functions; a Wasm reactor does not export them. Wasm binds callbacks during instantiation and delivers panics through scriptc.panic.
Set `"optimization": "dev"` in the profile to turn off release optimization. npm dependencies compile automatically, as in executables. Add `"npm_static": ["three"]` to name packages explicitly, like the [`--npm-static`](/docs/dependencies#explicit-package-selection) option. Unsupported code that the module reaches still produces a compiler diagnostic.
## Instantiate and initialize
A browser host needs a WASI Preview 1 adapter as well as the application's callbacks. Browsers do not supply WASI automatically. Inspect WebAssembly.Module.imports(module) to see the exact imports required by your compiled program. Supply real implementations or explicit failures for unsupported operations.
```js title="loader.js"
export async function loadCounter(url, wasi) {
const module = await WebAssembly.compileStreaming(fetch(url));
let api;
const instance = await WebAssembly.instantiate(module, {
...wasi.getImportObject(),
scriptc: {
changed(value) {
console.log(value);
},
panic(pointer, length) {
const bytes = new Uint8Array(api.memory.buffer, pointer, length);
throw new Error(new TextDecoder().decode(bytes));
},
},
});
api = instance.exports;
wasi.initialize(instance);
api.counter_init();
return api;
}
```
This loader assumes an adapter with getImportObject() and initialize(instance) methods, as provided by Node's node:wasi. Browser adapters may use different method names. Initialization must first connect the adapter to the instance's exported memory and invoke \_initialize once, then call the profile's init\_symbol. Do not call a command-style start(); reactors have no \_start export.
After initialization, counter\_step(2) returns 2, and another call returns 4. Calling counter\_init() again resets application globals and reevaluates module initialization. Instantiate the module again for independent state and memory.
## Values and memory ownership
| Profile class | Wasm boundary |
|---|---|
f64 |
JavaScript number. |
bool, u8, u32, i32 |
Wasm i32; booleans use 0 or 1. u32 values may appear as signed JavaScript numbers; use value >>> 0 to read them unsigned. |
i64, u64 |
JavaScript BigInt. The existing library integer checks and proofs restrict values to the exact JavaScript number range. |
string, bytes parameters |
Two i32 arguments: byte offset and byte length. Strings use UTF-8. Entry parameters are copied into runtime-owned values. |
string, bytes results |
Two extra i32 arguments identify writable four-byte output slots. The function writes the result pointer and byte length there, in little-endian order. |
cstring parameters |
One i32 argument: the byte offset of NUL-terminated UTF-8 text. The text is copied into a runtime-owned string; malformed UTF-8 becomes U+FFFD. A zero pointer traps with SC4012. |
cstring results |
An i32 result: the byte offset of NUL-terminated UTF-8 text in the result arena. A result containing U+0000 traps with SC4015 instead of being truncated. |
void |
No result. |
cstring callback parameter is one i32 pointer to NUL-terminated text, borrowed the same way; a value containing U+0000 traps with SC4015. The cstring class requires "profile\_format": 2. In native libraries it is a const char \* with the same rules.
Allocate host input buffers and output slots with scriptc\_alloc(size); a zero result indicates allocation failure. Release each allocation exactly once with scriptc\_free(pointer). Only free pointers returned by scriptc\_alloc. These allocations remain live across application calls, initialization, and collection until freed.
Result buffers belong to the module. If the profile declares abi.result\_reset\_symbol, results accumulate until that function is called. Otherwise, the next application export resets the result arena. Initialization and the optional abi.collect\_symbol also invalidate results. Allocation and free do not reset the arena. Copy a result into host-owned storage before invalidating it; never pass its pointer to scriptc\_free.
Recreate typed arrays and DataViews from memory.buffer after every Wasm call that may allocate. Memory growth replaces the backing buffer and invalidates older views. Pointers remain offsets into the instance's memory; never use a pointer with another instance.
## Errors and scheduling
A compiled trap or escaped exception calls scriptc.panic(pointer, length) with the native library's structured diagnostic bytes, then traps if the callback returns. Discard the instance after a panic, a Wasm trap, or an exception escaping a host import. Recovery uses a new instance; calling the initialization export does not repair a failed instance.
Host callbacks run synchronously. They must return before calling any application export, initialization, collection, allocation, or free on the same instance. Reentry is rejected. Copy callback data and schedule subsequent work after the outer call returns. The web app can call a frame export from requestAnimationFrame and render its results through Canvas, WebGL, or WebGPU.
See [Limitations](/docs/limitations#browser-embedding) for browser graphics and library-mode restrictions.
---
For a semantic overview of all documentation, see [/sitemap.md](/sitemap.md)
For an index of all available documentation, see [/llms.txt](/llms.txt)
For agent-facing discovery, including API and MCP surfaces, see [/agents.md](/agents.md)