pi-wasm-kit 0.0.0-stage → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 leepokai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/NOTICE

@@ -0,0 +1,11 @@
+pi-wasm-kit is an independent project by leepokai.
+
+Inspired by Finn Voorhees's PiDurableKit:
+https://github.com/finnvoor/PiDurableKit
+PiDurableKit demonstrates embedding Pi Durable in a host runtime with native
+capability bridges and an idiomatic API. This project applies that approach to
+QuickJS WebAssembly and JavaScript hosts. No affiliation or endorsement is implied.
+
+Powered by Earendil Works' Pi Durable, Pi AI, and Chord (MIT), and
+QuickJS / quickjs-emscripten (MIT). Upstream runtime code is bundled at build time,
+not reimplemented. Third-party license texts are distributed in dist/licenses.

package/README.md

@@ -1,3 +1,207 @@
-# Temporary Holding Version
+<p align="center">
+  <img src="https://raw.githubusercontent.com/leepokai/pi-wasm-kit/main/logos/export/logo-192.png" width="112" height="112" alt="Pi WASM Kit — continuation pi icon">
+</p>
+<h1 align="center">Pi WASM Kit</h1>
+<p align="center"><strong>Durable agents. A portable runtime.</strong><br>Run Pi in WebAssembly. Pick up from the last committed checkpoint.</p>
+<p align="center">
+  <a href="docs/install.md">Install</a> · <a href="#try-it">Quick start</a> · <a href="docs/api.md">API</a> · <a href="docs/features.md">Features</a> · <a href="docs/mobile.md">Mobile guide</a> · <a href="https://github.com/leepokai/pi-wasm-kit/releases">Releases</a>
+</p>
+<p align="center">
+  <a href="https://github.com/leepokai/pi-wasm-kit/releases"><img alt="Download SDK" src="https://img.shields.io/badge/DOWNLOAD-SDK-91ad60?style=for-the-badge&labelColor=22271f"></a>
+  <a href="examples/ios"><img alt="iOS example" src="https://img.shields.io/badge/iOS-EXAMPLE-91ad60?style=for-the-badge&logo=apple&logoColor=white&labelColor=22271f"></a>
+  <a href="examples/android"><img alt="Android example" src="https://img.shields.io/badge/ANDROID-EXAMPLE-91ad60?style=for-the-badge&logo=android&logoColor=white&labelColor=22271f"></a>
+</p>
+<p align="center">
+  <a href="https://www.npmjs.com/package/pi-wasm-kit"><img alt="npm version" src="https://img.shields.io/npm/v/pi-wasm-kit?color=627d3c"></a>
+  <a href="https://github.com/leepokai/pi-wasm-kit/actions/workflows/ci.yml"><img alt="CI" src="https://github.com/leepokai/pi-wasm-kit/actions/workflows/ci.yml/badge.svg"></a>
+  <a href="https://github.com/leepokai/pi-wasm-kit/actions/workflows/mobile.yml"><img alt="Mobile examples CI" src="https://github.com/leepokai/pi-wasm-kit/actions/workflows/mobile.yml/badge.svg"></a>
+  <a href="https://github.com/leepokai/pi-wasm-kit/releases"><img alt="Release including experimental prereleases" src="https://img.shields.io/github/v/release/leepokai/pi-wasm-kit?include_prereleases&color=627d3c"></a>
+  <a href="LICENSE"><img alt="MIT license" src="https://img.shields.io/github/license/leepokai/pi-wasm-kit?color=627d3c"></a>
+  <a href="https://github.com/leepokai/pi-wasm-kit/stargazers"><img alt="GitHub stars" src="https://img.shields.io/github/stars/leepokai/pi-wasm-kit?style=flat&color=627d3c"></a>
+</p>
+<p align="center">
+  <img alt="WebAssembly runtime" src="https://img.shields.io/badge/runtime-WebAssembly-654ff0?logo=webassembly&logoColor=white">
+  <img alt="Node.js 22.19 or newer" src="https://img.shields.io/badge/Node.js-22.19%2B-5f843d?logo=nodedotjs&logoColor=white">
+  <img alt="Browser IndexedDB storage" src="https://img.shields.io/badge/browser-IndexedDB-627d3c">
+  <img alt="iOS example requires iOS 26 or newer" src="https://img.shields.io/badge/iOS_example-26%2B-555?logo=apple&logoColor=white">
+  <img alt="Android example minimum API 26" src="https://img.shields.io/badge/Android_example-API_26%2B-627d3c?logo=android&logoColor=white">
+</p>
+<p align="center">Open source · MIT licensed · Experimental<br>
+Inspired by <a href="https://github.com/finnvoor/PiDurableKit">PiDurableKit</a> by <a href="https://github.com/finnvoor">Finn Voorhees</a>.</p>
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+![Browser playground](https://raw.githubusercontent.com/leepokai/pi-wasm-kit/main/docs/playground.png)
+
+The **actual upstream Pi Durable engine** runs inside QuickJS WASM. The host supplies a model transport, an exclusive durable journal, and explicitly granted tools. Stop the process or terminate the Worker, reopen the same journal, and Pi resumes unfinished tasks from committed checkpoints.
+
+**Experimental, v0.2.** Browser and Node hosts, plus [iOS and Android WebView examples](docs/mobile.md). Mobile examples run the same WASM engine on-device and call an actual Swift/Java tool. They load assets from a development server; they are not standalone offline apps. PostgreSQL and standalone WASI execution are not implemented.
+
+This is an independent project inspired by PiDurableKit’s Apple embedding design, not an official port or an endorsed project. PiDurableKit uses JavaScriptCore; this project uses QuickJS compiled to WebAssembly.
+
+## Install
+
+| Platform | Get started |
+| --- | --- |
+| macOS / Windows / Linux · Node.js | [Install the SDK from npm](docs/install.md#nodejs-sdk) |
+| Browser | [Run the playground](docs/install.md#browser-playground) |
+| iOS 26+ | [Build the Swift example](docs/install.md#ios) on macOS |
+| Android API 26+ | [Build and install the Android example](docs/install.md#android) |
+
+```sh
+npm install pi-wasm-kit
+```
+
+Requires Node.js 22.19+. This installs an SDK in your application, not a desktop/mobile app or a global CLI. See the [platform installation guide](docs/install.md) for prerequisites, Windows PowerShell commands, device setup and checksums.
+
+## Try it
+
+Requires Node.js 22.19+ and a modern browser with IndexedDB and Web Locks (HTTPS or localhost).
+
+```sh
+git clone https://github.com/leepokai/pi-wasm-kit.git
+cd pi-wasm-kit
+npm ci
+npm run build
+npm run dev
+```
+
+Open the local URL. The demo uses a **deterministic local model**, not an LLM: every prompt demonstrates multiplying 21 by 2, with delayed model responses so you can interrupt it. The Pi engine, tool execution, WebAssembly, storage, and recovery are real.
+
+1. Click **Run**.
+2. While running, click **Interrupt runtime**. This actually terminates the Worker.
+3. Click **Reopen & resume**. The existing journal is reopened.
+4. Refresh the page. The saved conversation remains.
+
+Optionally enter an OpenAI Chat Completions-compatible endpoint and model in **Model connection**, then interrupt and reopen. The endpoint must allow your origin through CORS. Use your own authenticated backend proxy; this demo has no login and does not store API keys. The endpoint and model selection are retained in localStorage so refreshing uses the same transport.
+
+## Mobile examples
+
+- **[iOS / Swift](examples/ios)** — WKWebView, native tool, app-relaunch recovery, and iOS 26+ `BGContinuedProcessingTask`.
+- **[Android / Java](examples/android)** — Android WebView, origin-scoped native tool, process-restart recovery.
+
+The [mobile guide](docs/mobile.md) explains asset hosting, platform limits, and how to reproduce the native E2E checks. Background execution is separate from durability: a saved task can survive an interruption without receiving more background CPU time.
+
+## Node example with a real model
+
+```sh
+PI_MODEL=your-model PI_API_KEY=your-key \
+PI_BASE_URL=https://your-compatible-provider.example/v1 \
+node examples/node/chat.mjs 'Hello from WASM'
+```
+
+`PI_BASE_URL` defaults to `https://api.openai.com/v1`. Credentials stay in the host transport and are not passed to the WASM guest. Journals contain prompts, model responses, tool arguments/results and application state; handle them as sensitive data.
+
+## Use the SDK
+
+Install from [npm](https://www.npmjs.com/package/pi-wasm-kit) with `npm install pi-wasm-kit`. For an exact version, use `npm install pi-wasm-kit@0.2.0`. You can also build from source with `npm pack`, or install the tarball from the GitHub release.
+
+```ts
+import { PiWasmAgent } from 'pi-wasm-kit';
+import { openNodeJournal } from 'pi-wasm-kit/node';
+import { openAICompatible } from 'pi-wasm-kit/openai';
+
+const agent = await PiWasmAgent.open({
+  journal: await openNodeJournal('./agent.jsonl'),
+  model: openAICompatible({
+    baseURL: process.env.PI_BASE_URL!,
+    model: process.env.PI_MODEL!,
+    apiKey: process.env.PI_API_KEY,
+  }),
+  tools: [{
+    name: 'multiply',
+    description: 'Multiply two numbers',
+    parameters: {
+      type: 'object',
+      properties: { a: { type: 'number' }, b: { type: 'number' } },
+      required: ['a', 'b'],
+    },
+    replay: 'safe', // Only for operations safe to repeat after interruption.
+    execute: ({ a, b }, { signal, output, taskId }) => {
+      signal.throwIfAborted();
+      output('Calculating…');
+      return String(Number(a) * Number(b));
+    },
+  }],
+  onEvent(event) {
+    if (event.type === 'events') console.log(event.events);
+  },
+});
+
+try {
+  const { id } = await agent.submit('Multiply 21 by 2', 'request-001');
+  await agent.wait(id);
+  console.log(await agent.view());
+} finally {
+  await agent.close();
+}
+```
+
+In a browser Worker, replace `openNodeJournal` with `openBrowserJournal` from `pi-wasm-kit/browser`. Use a bundler such as Vite to serve the QuickJS WASM assets. The included demo shows the complete Worker bridge. Do not run CPU-bound guest code on the UI thread.
+
+`model` can be any host function returning a Pi `AssistantMessage`. Its third argument accepts Pi `AssistantMessageEvent` values for incremental text, thinking and tool-call updates. The supplied HTTP adapter currently **buffers Chat Completions responses**; use a streaming `ModelHandler` for token-level events. The final message is returned from the handler; the bridge emits its terminal event.
+
+## What is preserved from PiDurableKit?
+
+The goal is to retain Pi’s capabilities rather than replace its scheduler with a simplified loop. See the [feature matrix](docs/features.md) for exact boundaries.
+
+| Capability | Available here |
+| --- | --- |
+| Durable conversations and interrupted-run recovery | Upstream Pi + persisted journal |
+| Input deduplication, steering, follow-ups | `submit`, `submitDraft`, `whenBusy` |
+| Configuration, reset, fork and compaction | First-class host methods |
+| Host tools, schema validation, progress and cancellation | JSON bridge, explicit host capabilities |
+| Safe/unsafe tool replay | Upstream Pi policy, safe requires opt-in |
+| Events, usage, task inspection and graph | `onEvent`, `watch`, `view`, `inspect`, `taskGraph` |
+| JS extensions, tools, prompt sections, hooks and wrappers | CommonJS extension sources inside WASM |
+| Documents, transactions, custom/child tasks and subagents | Upstream API inside extensions and `evaluate` |
+| Apple Keychain, OAuth helpers, native filesystem/shell | Host integration required; not bundled |
+| Android / iOS app integration | Origin-scoped native tool bridges, persistent WebView journals; [examples](docs/mobile.md) |
+| iOS continued background processing | iOS 26+ adapter, progress, expiration and durable cancellation; device scheduling remains system-controlled |
+
+## Extensions and advanced Pi APIs
+
+Install a CommonJS source string at open time. Supported `require` names are `@earendil-works/pi-durable`, `@earendil-works/pi-ai` (**Type only**) and `@earendil-works/chord/context`.
+
+```ts
+const agent = await PiWasmAgent.open({
+  journal,
+  model,
+  extensions: [counterExtensionSource],
+});
+```
+
+See [the counter extension](examples/extensions/counter.cjs): a tool, prompt section, wrapper, transactionally deduplicated document mutation, and custom durable task. Definitions must be installed again on recovery; the journal stores task kinds and checkpoints, **not executable source code**. `install(source)` and `uninstall(name)` change the live registry.
+
+For advanced integration, `evaluate(source, args, conversationId?)` runs a trusted async function body inside WASM. It receives `pi`, `Type`, `harness`, `conversation`, `registry`, `context`, and JSON `args`. This exposes the upstream document, task, hook and transaction APIs without attempting to serialize functions across the boundary.
+
+```ts
+const taskId = await agent.evaluate<number>(`
+  const task = registry.snapshot().task('example.double');
+  return conversation.commit(tx => tx.createTask(task, args, {
+    ownership: { kind: 'conversation' }
+  }), context);
+`, { value: 21 });
+const result = await agent.waitForTask(taskId);
+```
+
+Extension source and `evaluate` are **trusted application code**, not a multitenant plugin security boundary. Extensions share one guest and its granted capabilities. Do not evaluate arbitrary user/model-generated code with powerful host tools. See [architecture and durability](docs/architecture.md) and the [API guide](docs/api.md).
+
+## Validation
+
+```sh
+npm test                         # Real WASM integration tests + local HTTP transport
+npx playwright install chromium
+npm run build:demo               # Production browser bundle
+npm run test:e2e                  # Production Worker termination, reload, exclusion
+npm run typecheck
+npm run test:package              # Install the tarball into a clean consumer
+```
+
+Tests use synthetic model responses and a local HTTP fixture. They do not require paid credentials or claim to validate a live provider’s service. CI repeats the suite on Linux. Recovery is at committed task boundaries, not a snapshot of a JavaScript stack or an in-flight HTTP connection.
+
+## Credits and license
+
+- **Inspired by [PiDurableKit](https://github.com/finnvoor/PiDurableKit), by [Finn Voorhees](https://github.com/finnvoor).** Its Apple embedding design motivated this WASM host adaptation. No PiDurableKit Swift implementation is copied.
+- Powered by [Pi Durable, Pi AI and Chord](https://github.com/earendil-works/pi), by Earendil Works and contributors; the upstream MIT notice credits Mario Zechner.
+- Executes JavaScript using [quickjs-emscripten](https://github.com/justjake/quickjs-emscripten) and [QuickJS](https://bellard.org/quickjs/).
+
+This project is MIT licensed. See [LICENSE](LICENSE), [NOTICE](NOTICE), and [third-party notices](third-party/README.md). Builds include `dist/licenses` with the license texts for bundled dependencies. Upstream licenses remain applicable.

package/dist/engine.d.ts

@@ -0,0 +1,30 @@
+type Handler = (method: string, data: any, signal: AbortSignal, update: (value: unknown) => void) => Promise<unknown>;
+/** JSON-only boundary. No host objects or ambient filesystem/network enter the VM. */
+export declare class Engine {
+    private handler;
+    private emit;
+    private cpuMs;
+    private vm;
+    private runtime;
+    private stopped;
+    private queued;
+    private pumps;
+    private deadline;
+    private timers;
+    private nextTimer;
+    private pending;
+    private controller;
+    private activeCalls;
+    private disposal?;
+    private effects;
+    private constructor();
+    static create(handler: Handler, emit: (event: any) => void, cpuMs?: number, memory?: number): Promise<Engine>;
+    private run;
+    private expose;
+    private install;
+    private settle;
+    private pump;
+    call<T>(method: string, data?: unknown): Promise<T>;
+    dispose(): Promise<void>;
+}
+export {};

package/dist/engine.js

@@ -0,0 +1,246 @@
+import { newQuickJSWASMModuleFromVariant } from 'quickjs-emscripten-core';
+import variant from '@jitl/quickjs-wasmfile-release-sync';
+// The upstream variant uses a CJS declaration file for its ESM default export.
+let modulePromise;
+const getQuickJS = () => modulePromise ??= newQuickJSWASMModuleFromVariant(variant);
+import source from './guest-source.js';
+/** JSON-only boundary. No host objects or ambient filesystem/network enter the VM. */
+export class Engine {
+    handler;
+    emit;
+    cpuMs;
+    vm;
+    runtime;
+    stopped = false;
+    queued = false;
+    pumps = 0;
+    deadline = Infinity;
+    timers = new Map();
+    nextTimer = 1;
+    pending = new Set();
+    controller = new AbortController();
+    activeCalls = new Set();
+    disposal;
+    effects = new Map();
+    constructor(module, handler, emit, cpuMs, memory) {
+        this.handler = handler;
+        this.emit = emit;
+        this.cpuMs = cpuMs;
+        this.runtime = module.newRuntime();
+        this.runtime.setMemoryLimit(memory);
+        this.runtime.setMaxStackSize(1024 * 1024);
+        this.runtime.setInterruptHandler(() => this.stopped || performance.now() > this.deadline);
+        this.vm = this.runtime.newContext();
+        try {
+            this.install();
+            this.run(() => this.vm.unwrapResult(this.vm.evalCode(source, 'pi-durable.guest.js')).dispose());
+        }
+        catch (error) {
+            this.vm.dispose();
+            this.runtime.dispose();
+            throw new Error(error instanceof Error ? error.message : String(error));
+        }
+    }
+    static async create(handler, emit, cpuMs = 1000, memory = 64 * 1024 * 1024) {
+        return new Engine(await getQuickJS(), handler, emit, cpuMs, memory);
+    }
+    run(fn) {
+        this.deadline = performance.now() + this.cpuMs;
+        try {
+            return fn();
+        }
+        finally {
+            this.deadline = Infinity;
+        }
+    }
+    expose(name, fn) {
+        const handle = this.vm.newFunction(name, fn);
+        this.vm.setProp(this.vm.global, name, handle);
+        handle.dispose();
+    }
+    install() {
+        this.expose('__cancel', id => { this.effects.get(this.vm.getNumber(id))?.controller.abort(); });
+        this.expose('__host', (method, raw, callback, requestId) => {
+            const name = this.vm.getString(method);
+            const data = JSON.parse(this.vm.getString(raw));
+            const promise = this.vm.newPromise();
+            this.pending.add(promise);
+            const id = requestId ? this.vm.getNumber(requestId) : 0;
+            const effect = { controller: new AbortController(), callback: callback && this.vm.typeof(callback) === 'function' ? callback.dup() : undefined };
+            if (id)
+                this.effects.set(id, effect);
+            const signal = AbortSignal.any([this.controller.signal, effect.controller.signal]);
+            const update = (value) => {
+                if (this.stopped || signal.aborted || !effect.callback?.alive)
+                    return;
+                const raw = this.vm.newString(JSON.stringify(value));
+                try {
+                    this.run(() => this.vm.unwrapResult(this.vm.callFunction(effect.callback, this.vm.undefined, raw)).dispose());
+                }
+                finally {
+                    raw.dispose();
+                    this.pump();
+                }
+            };
+            const finish = (value, failed) => {
+                if (effect.callback?.alive)
+                    effect.callback.dispose();
+                if (id)
+                    this.effects.delete(id);
+                this.settle(promise, value, failed);
+            };
+            void Promise.resolve().then(() => this.handler(name, data, signal, update)).then(value => finish(value, false), error => finish(error instanceof Error ? error.message : String(error), true));
+            return promise.handle;
+        });
+        this.expose('__emit', raw => { this.emit(JSON.parse(this.vm.getString(raw))); });
+        this.expose('__hostSync', (name, arg) => {
+            const method = this.vm.getString(name);
+            const value = this.vm.getString(arg);
+            switch (method) {
+                case 'url': {
+                    const [input, base] = JSON.parse(value);
+                    const url = new URL(input, base ?? undefined);
+                    return this.vm.newString(JSON.stringify({ href: url.href, origin: url.origin, protocol: url.protocol, username: url.username, password: url.password, host: url.host, hostname: url.hostname, port: url.port, pathname: url.pathname, search: url.search, hash: url.hash }));
+                }
+                case 'now': return this.vm.newString(String(performance.now()));
+                case 'uuid': return this.vm.newString(JSON.stringify(crypto.randomUUID()));
+                case 'random': return this.vm.newString(JSON.stringify(Array.from(crypto.getRandomValues(new Uint8Array(Number(value))))));
+                case 'encode': return this.vm.newString(JSON.stringify(Array.from(new TextEncoder().encode(value))));
+                case 'decode': return this.vm.newString(JSON.stringify(new TextDecoder().decode(Uint8Array.from(JSON.parse(value)))));
+                default: throw new Error('Unknown synchronous capability');
+            }
+        });
+        this.expose('__timer', (fn, delay) => {
+            const id = this.nextTimer++;
+            const callback = fn.dup();
+            const timer = setTimeout(() => {
+                this.timers.delete(id);
+                if (this.stopped)
+                    return;
+                try {
+                    this.run(() => this.vm.unwrapResult(this.vm.callFunction(callback, this.vm.undefined)).dispose());
+                }
+                catch (error) {
+                    this.emit({ type: 'error', message: String(error) });
+                }
+                finally {
+                    callback.dispose();
+                    this.pump();
+                }
+            }, Math.min(Math.max(0, this.vm.getNumber(delay)), 2147483647));
+            this.timers.set(id, { timer, callback });
+            return this.vm.newNumber(id);
+        });
+        this.expose('__clearTimer', id => {
+            const key = this.vm.getNumber(id);
+            const item = this.timers.get(key);
+            if (item) {
+                clearTimeout(item.timer);
+                item.callback.dispose();
+                this.timers.delete(key);
+            }
+        });
+    }
+    settle(promise, value, failed) {
+        if (this.stopped)
+            return;
+        const handle = failed ? this.vm.newError(String(value)) : this.vm.newString(JSON.stringify(value ?? null));
+        try {
+            this.run(() => failed ? promise.reject(handle) : promise.resolve(handle));
+        }
+        finally {
+            handle.dispose();
+            promise.dispose();
+            this.pending.delete(promise);
+        }
+        this.pump();
+    }
+    pump() {
+        if (this.queued || this.stopped)
+            return;
+        this.queued = true;
+        const schedule = ++this.pumps % 16 === 0 ? (fn) => setTimeout(fn, 0) : queueMicrotask;
+        schedule(() => {
+            this.queued = false;
+            if (this.stopped)
+                return;
+            const result = this.run(() => this.runtime.executePendingJobs(100));
+            if (result.error) {
+                const message = JSON.stringify(this.vm.dump(result.error));
+                result.error.dispose();
+                this.emit({ type: 'error', message });
+            }
+            if (this.runtime.hasPendingJob())
+                this.pump();
+        });
+    }
+    async call(method, data = {}) {
+        if (this.stopped)
+            throw new Error('WASM runtime is closed');
+        const fn = this.vm.getProp(this.vm.global, '__dispatch');
+        const name = this.vm.newString(method);
+        const raw = this.vm.newString(JSON.stringify(data));
+        let promise;
+        try {
+            promise = this.run(() => this.vm.unwrapResult(this.vm.callFunction(fn, this.vm.undefined, name, raw)));
+        }
+        finally {
+            fn.dispose();
+            name.dispose();
+            raw.dispose();
+        }
+        let release;
+        const released = new Promise(resolve => { release = resolve; });
+        this.activeCalls.add(released);
+        const signal = this.controller.signal;
+        let onAbort;
+        try {
+            const stopped = new Promise((_, reject) => { onAbort = () => reject(new Error('WASM runtime was terminated')); signal.addEventListener('abort', onAbort, { once: true }); });
+            const resolved = this.vm.resolvePromise(promise).then(result => {
+                if (this.stopped) {
+                    if (result.error)
+                        result.error.dispose();
+                    else
+                        result.value.dispose();
+                    throw new Error('WASM runtime was terminated');
+                }
+                const value = this.vm.unwrapResult(result);
+                try {
+                    return JSON.parse(this.vm.getString(value));
+                }
+                finally {
+                    value.dispose();
+                }
+            });
+            this.pump();
+            return await Promise.race([resolved, stopped]);
+        }
+        finally {
+            signal.removeEventListener('abort', onAbort);
+            promise.dispose();
+            this.activeCalls.delete(released);
+            release();
+        }
+    }
+    dispose() {
+        if (this.disposal)
+            return this.disposal;
+        this.stopped = true;
+        this.controller.abort();
+        for (const effect of this.effects.values())
+            if (effect.callback?.alive)
+                effect.callback.dispose();
+        this.effects.clear();
+        for (const { timer, callback } of this.timers.values()) {
+            clearTimeout(timer);
+            callback.dispose();
+        }
+        this.timers.clear();
+        for (const promise of this.pending)
+            promise.dispose();
+        this.pending.clear();
+        // Rejected call() waiters must release their handles before freeing the context.
+        this.disposal = Promise.all([...this.activeCalls]).then(() => { this.vm.dispose(); this.runtime.dispose(); });
+        return this.disposal;
+    }
+}

package/dist/guest/bridge.d.ts

@@ -0,0 +1 @@
+export declare function hostCall(name: string, value: unknown, signal?: AbortSignal, update?: (value: any) => void): Promise<any>;

package/dist/guest/bridge.js

@@ -0,0 +1,14 @@
+let nextId = 1;
+export async function hostCall(name, value, signal, update) {
+    signal?.throwIfAborted();
+    const id = nextId++;
+    const abort = () => __cancel(id);
+    const pending = __host(name, JSON.stringify(value), raw => update?.(JSON.parse(raw)), id);
+    signal?.addEventListener('abort', abort, { once: true });
+    try {
+        return JSON.parse(await pending);
+    }
+    finally {
+        signal?.removeEventListener('abort', abort);
+    }
+}

package/dist/guest/entry.d.ts

@@ -0,0 +1 @@
+import './platform.js';