@dcasegr/skein 0.0.0-stage → 0.1.1

package/dist/host/testhost.js

@@ -0,0 +1,211 @@
+// A test host (#40): a router over a temporary host.db and SKEIN_HOME,
+// instances (mailbox instances among them) with keys of their own (the signer's stand-in). With no
+// host skein its own origin's BRC-169 requests are answered by a fixture over
+// host.db (fake-discovery.ts); `hostSkein()` makes the real one (#113): the host
+// skein with the onboarding app installed, which then answers them.
+import { existsSync, statSync } from "node:fs";
+import * as fs from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { PrivateKey } from "@bsv/sdk";
+import * as dagCbor from "@ipld/dag-cbor";
+import { dirBundles } from "../client/client.js";
+import { RawBox, signClaim } from "../client/raw.js";
+import { InferPeer } from "../peers/infer.js";
+import { ephemeralWallet } from "../wallet.js";
+import { CHAT_APP, installApps, ONBOARD_APP, SHELL_APP } from "../testapps.js";
+import { fakeDiscovery } from "./fake-discovery.js";
+import { imageSource } from "./boot.js";
+import { HostDb } from "./instances.js";
+import { Router } from "./router.js";
+import { Signer } from "./signer.js";
+const ROOT = join(fileURLToPath(new URL(".", import.meta.url)), "../..");
+export const until = async (what, f, ms = 30_000) => {
+    for (const end = Date.now() + ms; Date.now() < end;) {
+        const v = await f();
+        if (v)
+            return v;
+        await new Promise((r) => setTimeout(r, 50));
+    }
+    throw new Error(`timed out: ${what}`);
+};
+/**
+ * The messages an instance took in, in log order (#68): a mail entry of its
+ * own (a host that admits one directly), or a message a request's thread
+ * routed — the `admit` of the front door's answer on that thread's updates.
+ */
+export async function messagesIn(store) {
+    const byInput = new Map();
+    for await (const t of store.edges.query({ kind: "thread" })) {
+        const o = await store.get(t);
+        if (o.args?.request && o.input)
+            byInput.set(o.input.toString(), t);
+    }
+    const out = [];
+    for await (const { cid, entry } of store.log.entries(1)) {
+        const mail = entry.mail;
+        if (mail) {
+            out.push(await store.get(mail));
+            continue;
+        }
+        const t = byInput.get(cid.toString());
+        if (!t)
+            continue;
+        for await (const u of store.chains.history(t)) {
+            if (u.equals(t))
+                continue;
+            const up = await store.get(u);
+            if (!up.result?.stdout?.length)
+                continue;
+            let a;
+            try {
+                a = dagCbor.decode(up.result.stdout);
+            }
+            catch {
+                continue;
+            } // stdout that is not dag-cbor admitted nothing
+            for (const x of a.admit ?? [])
+                if (x.mail)
+                    out.push(x.mail);
+        }
+    }
+    return out;
+}
+/** A host with instances (mailbox instances among them), each instance's key its own (the signer's stand-in). */
+export async function testHost(t, o = {}) {
+    const home = await fs.mkdtemp(join(tmpdir(), "skein-router-"));
+    // #96: o.lmdb — every instance a set of one LMDB environment, <home>/store (host.db `lmdb:<dir>`), else a file each.
+    // #158: o.rocks — every instance a set of one RocksDB database, <home>/store-rocksdb, run by one `skein-kernel host` process.
+    // The settled split: o.sqlite (or SKEIN_TEST_STORE=sqlite) — every instance a set of one SQLite database, <home>/store.sqlite, on the wasm kernel.
+    const sqlite = o.sqlite ?? process.env.SKEIN_TEST_STORE === "sqlite";
+    const storeOf = (handle) => (sqlite ? `sqlite:${join(home, "store.sqlite")}` : o.rocks ? `rocksdb:${join(home, "store-rocksdb")}` : o.lmdb ? `lmdb:${join(home, "store")}` : join(home, "instances", handle, "runtime.db"));
+    t.after(() => fs.rm(home, { recursive: true, force: true }));
+    const db = new HostDb(join(home, "host.db"));
+    const keys = new Map();
+    const keyOf = (h) => { let k = keys.get(h); if (!k) {
+        k = PrivateKey.fromRandom();
+        keys.set(h, k);
+    } return k; };
+    const ownerKey = o.ownerKey ?? PrivateKey.fromRandom();
+    const owner = ephemeralWallet(ownerKey), ownerId = ownerKey.toPublicKey().toString();
+    const lines = [];
+    const providerMaster = PrivateKey.fromRandom();
+    const router = new Router({
+        db, walletFor: (row) => ephemeralWallet(keyOf(row.handle)), owner: ownerId, infer: o.infer, home,
+        idleMs: o.idleMs ?? 0, http: o.http, ownerMessagebox: o.ownerMessagebox, genesis: o.genesis, now: o.now, ledgerMs: 60_000, kernel: { env: { SKEIN_HOME: home } },
+        // A broadcaster (#58, #65): its Arcade, and so a `status` provider.
+        ...(o.arc ? { arc: o.arc } : {}), ...(o.arcRetry ? { arcRetry: o.arcRetry } : {}),
+        // The host's headers feed (#102).
+        ...(o.headersFeed ? { headersFeed: o.headersFeed } : {}),
+        // #130: what the host bills (billing.ts); none: it bills no one.
+        ...(o.billing ? { billing: o.billing } : {}),
+        ...(o.lmdb ? { lmdbStore: join(home, "store") } : {}),
+        ...(o.rocks ? { rocksStore: join(home, "store-rocksdb") } : {}),
+        // The settled split: the wasm kernel over the host's one SQLite database (SKEIN_TEST_STORE=sqlite: every test host so).
+        ...(sqlite ? { sqliteStore: join(home, "store.sqlite") } : {}),
+        // #113: with no host skein, discovery over host.db (a fixture); hostSkein() makes the real server.
+        discovery: fakeDiscovery(db, () => router),
+        // The host's providers (#70) under keys of its own, as `skein-host run` derives them.
+        providerKeyFor: (name) => new Signer(providerMaster).providerKey(name),
+        log: (s, l) => { lines.push(`[${s}] ${l}`); if (process.env.VERBOSE)
+            console.log(`[${s}] ${l}`); },
+    });
+    t.after(async () => { await router.stop(); db.close(); });
+    await router.listen(0);
+    const base = `http://127.0.0.1:${router.port}`;
+    const h = {
+        home, db, router, base, owner, ownerKey, ownerId, lines, keyOf,
+        /**
+         * An instance's row (host.db kind `agent`: not a mailbox instance), its
+         * genesis at first hydration (the owner's mailbox must exist first to be
+         * named in it). Its identity key (hex).
+         */
+        instance(handle) { db.add(handle, { store: storeOf(handle), identity: keyOf(handle).toPublicKey().toString() }); return keyOf(handle).toPublicKey().toString(); },
+        /** The same as `instance`, by its old name (for tests written before the rename). */
+        agent(handle) { return h.instance(handle); },
+        /**
+         * An instance booted from an image (#89; default: the default image,
+         * images/default): no owner in its genesis, the claim row from anyone.
+         * Claim it with a message from the owner's wallet in box `claim`
+         * (src/testapps.ts sendPlan of planClaim, #127): its sender owns it.
+         */
+        async image(handle, dir = join(ROOT, "images/default")) {
+            db.add(handle, { store: storeOf(handle), identity: keyOf(handle).toPublicKey().toString() });
+            return await router.bootRow(handle, await imageSource(dir), { image: true });
+        },
+        /** A mailbox instance's row (a fixture's: its genesis at first hydration; the product path is the manager's create, Router.createInstance image `mailbox`). */
+        mailbox(handle, whose) { db.add(handle, { kind: "mailbox", owner: whose, store: storeOf(handle), identity: keyOf(handle).toPublicKey().toString() }); },
+        /**
+         * The host skein (#90, #113, #142): `host` from the host image (the
+         * default image with the onboarding app), its genesis naming the owner
+         * (the operator's key here), the instance manager and the certifier in
+         * its address book; the onboarding app's config at birth over its
+         * manifest's (default: domain `localhost`, origin this router's). Its own
+         * origin's BRC-169 requests are then the app's.
+         */
+        async hostSkein(config = {}) {
+            const c = await router.createInstance("host", ownerId, { host: true, appConfig: { onboard: { onboard: { domain: "localhost", origin: base, ...config } } } });
+            await router.hydrate("host");
+            await router.settled();
+            return c;
+        },
+        origin: (handle) => router.originOf(handle),
+        storeSize(handle) { const p = db.get(handle).store; return statSync(p).size + (existsSync(`${p}-wal`) ? statSync(`${p}-wal`).size : 0); },
+        /**
+         * Install apps into an instance as the owner (#83: a genesis has no shell,
+         * no `run`, no `chat`): by default the shell app and the chat app, through
+         * the owner's messages (src/testapps.ts installApps, #124). Hydrates the instance first.
+         */
+        async install(handle, apps = [SHELL_APP, CHAT_APP]) {
+            await router.hydrate(handle);
+            await installApps({ home, port: router.port, owner, settled: () => router.settled() }, handle, apps);
+        },
+        async entries(handle) { const k = (await router.hydrate(handle)).kernel; return (await k.store.get((await k.store.log.tip()))).n + 1; },
+    };
+    return h;
+}
+/**
+ * A small world on a test host (the explorer's and the store reader's tests):
+ * the owner's mailbox, the inference peer's, and instance `alpha` with the shell
+ * app and the chat app installed (#83); `dir` imported into alpha (objects →
+ * `main`); a chat whose turn makes one bash
+ * tool call (`ls | head -3`) and answers "README and **src**." into the
+ * owner's mailbox. The peer answers from a script, over its raw transport.
+ */
+export async function chatWorld(t, dir, o = {}) {
+    const inferKey = PrivateKey.fromRandom(), inferId = inferKey.toPublicKey().toString();
+    const h = await testHost(t, { infer: inferId, ...o });
+    h.mailbox("david", h.ownerId);
+    h.mailbox("infer", inferId);
+    const alpha = h.instance("alpha");
+    await h.router.start();
+    await h.install("alpha");
+    const reply = (message) => new Response(JSON.stringify({ choices: [{ message: { role: "assistant", ...message } }], usage: { prompt_tokens: 10, completion_tokens: 5 }, model: "qwen38" }), { status: 200 });
+    const script = [
+        reply({ content: "", tool_calls: [{ id: "call-1", type: "function", function: { name: "bash", arguments: JSON.stringify({ cmd: "ls | head -3" }) } }] }),
+        reply({ content: "README and **src**." }),
+    ];
+    const w = ephemeralWallet(inferKey);
+    const peer = new InferPeer({
+        wallet: w, providers: { ripper: { baseUrl: "http://ripper.test/v1" } }, log: (l) => h.lines.push(`[infer] ${l}`),
+        fetch: (async () => script.shift() ?? new Response("no more", { status: 500 })),
+        raw: {
+            inbox: new RawBox(w, `${h.base}/@infer`),
+            outbox: (url) => new RawBox(w, url),
+            addressOf: (k) => { const r = h.db.list().find((x) => x.identity === k && x.kind !== "mailbox"); return r && h.origin(r.handle); },
+        },
+    });
+    const owner = new RawBox(h.owner, `${h.base}/@alpha`);
+    const { root, bundles } = await dirBundles(dir);
+    for (const b of bundles)
+        await owner.send(alpha, "objects", b);
+    const chat = (await owner.send(alpha, "chat", { text: "What is here?" })).id;
+    const mine = new RawBox(h.owner, `${h.base}/@david`);
+    await until("alpha's answer", async () => {
+        await peer.poll();
+        return (await mine.list("chat")).find((m) => m.value.text === "README and **src**.");
+    }, 60_000);
+    await h.router.settled();
+    return { h, alpha, root, chat, store: h.db.get("alpha").store };
+}

package/dist/host/vcdiff.d.ts

@@ -0,0 +1,9 @@
+export declare class VcdiffError extends Error {
+}
+/** apply(delta, source): the target bytes. */
+export declare function vcdiffDecode(delta: Uint8Array, source?: Uint8Array): Uint8Array;
+/**
+ * A minimal encoder (tests and `pack --patch`): one window over the whole
+ * source, the longest common prefix and suffix as COPYs, the middle as an ADD.
+ */
+export declare function vcdiffEncode(target: Uint8Array, source?: Uint8Array): Uint8Array;

package/dist/host/vcdiff.js

@@ -0,0 +1,210 @@
+// RFC 3284 VCDIFF, decode only: what an `ordfs/patch` output carries (gib's
+// file edits; ~/Work/bsv/gib-cli docs/plans/ordfs-formats.html). The profile
+// gib's writers emit is the plain one — header D6 C3 C4 00, no secondary
+// compression, no custom code table — and this decoder takes exactly that
+// (plus xdelta3's application header and Adler-32 window checksum, which it
+// skips/verifies), any number of windows, VCD_SOURCE and VCD_TARGET.
+export class VcdiffError extends Error {
+}
+const NOOP = 0, ADD = 1, RUN = 2, COPY = 3;
+const S_NEAR = 4, S_SAME = 3;
+/** The default code table (RFC 3284 §5.6): 256 entries of one or two instructions. */
+const TABLE = (() => {
+    const t = [];
+    const i = (type, size = 0, mode = 0) => ({ type, size, mode });
+    const none = i(NOOP);
+    t.push([i(RUN, 0), none]);
+    for (let s = 0; s <= 17; s++)
+        t.push([i(ADD, s), none]);
+    for (let m = 0; m <= 8; m++) {
+        t.push([i(COPY, 0, m), none]);
+        for (let s = 4; s <= 18; s++)
+            t.push([i(COPY, s, m), none]);
+    }
+    for (let m = 0; m <= 5; m++)
+        for (let a = 1; a <= 4; a++)
+            for (let c = 4; c <= 6; c++)
+                t.push([i(ADD, a), i(COPY, c, m)]);
+    for (let m = 6; m <= 8; m++)
+        for (let a = 1; a <= 4; a++)
+            t.push([i(ADD, a), i(COPY, 4, m)]);
+    for (let m = 0; m <= 8; m++)
+        t.push([i(COPY, 4, m), i(ADD, 1)]);
+    if (t.length !== 256)
+        throw new Error("vcdiff code table");
+    return t;
+})();
+class Reader {
+    b;
+    at;
+    end;
+    constructor(b, at = 0, end = b.length) { this.b = b; this.at = at; this.end = end; }
+    byte() {
+        if (this.at >= this.end)
+            throw new VcdiffError("vcdiff: truncated");
+        return this.b[this.at++];
+    }
+    int() {
+        let v = 0;
+        for (let n = 0; n < 9; n++) {
+            const x = this.byte();
+            v = v * 128 + (x & 0x7f);
+            if (v > Number.MAX_SAFE_INTEGER)
+                throw new VcdiffError("vcdiff: integer overflow");
+            if (!(x & 0x80))
+                return v;
+        }
+        throw new VcdiffError("vcdiff: integer too long");
+    }
+    take(n) {
+        if (this.at + n > this.end)
+            throw new VcdiffError("vcdiff: truncated");
+        const s = this.b.subarray(this.at, this.at + n);
+        this.at += n;
+        return s;
+    }
+}
+function adler32(b) {
+    let a = 1, s = 0;
+    for (const x of b) {
+        a = (a + x) % 65521;
+        s = (s + a) % 65521;
+    }
+    return ((s << 16) | a) >>> 0;
+}
+/** apply(delta, source): the target bytes. */
+export function vcdiffDecode(delta, source = new Uint8Array(0)) {
+    const r = new Reader(delta);
+    if (r.byte() !== 0xd6 || r.byte() !== 0xc3 || r.byte() !== 0xc4)
+        throw new VcdiffError("vcdiff: bad magic");
+    if (r.byte() !== 0)
+        throw new VcdiffError("vcdiff: unsupported version");
+    const hdr = r.byte();
+    if (hdr & 0x01)
+        throw new VcdiffError("vcdiff: secondary compression is not supported");
+    if (hdr & 0x02)
+        throw new VcdiffError("vcdiff: custom code tables are not supported");
+    if (hdr & ~0x07)
+        throw new VcdiffError("vcdiff: unknown header bits");
+    if (hdr & 0x04)
+        r.take(r.int()); // xdelta3's application header
+    const out = [];
+    let target = new Uint8Array(0);
+    while (r.at < r.end) {
+        const win = r.byte();
+        if (win & ~0x07)
+            throw new VcdiffError("vcdiff: unknown window bits");
+        if ((win & 0x03) === 0x03)
+            throw new VcdiffError("vcdiff: VCD_SOURCE and VCD_TARGET together");
+        let seg = new Uint8Array(0);
+        if (win & 0x03) {
+            const len = r.int(), pos = r.int();
+            const from = win & 0x01 ? source : target;
+            if (pos + len > from.length)
+                throw new VcdiffError("vcdiff: source segment out of range");
+            seg = from.subarray(pos, pos + len);
+        }
+        const encLen = r.int();
+        const encEnd = r.at + encLen;
+        if (encEnd > r.end)
+            throw new VcdiffError("vcdiff: truncated window");
+        const tlen = r.int();
+        if (r.byte() !== 0)
+            throw new VcdiffError("vcdiff: compressed sections are not supported");
+        const dlen = r.int(), ilen = r.int(), alen = r.int();
+        const sum = win & 0x04 ? (r.byte() << 24 | r.byte() << 16 | r.byte() << 8 | r.byte()) >>> 0 : undefined;
+        const data = new Reader(delta, r.at, r.at + dlen);
+        r.take(dlen);
+        const inst = new Reader(delta, r.at, r.at + ilen);
+        r.take(ilen);
+        const addr = new Reader(delta, r.at, r.at + alen);
+        r.take(alen);
+        if (r.at !== encEnd)
+            throw new VcdiffError("vcdiff: window length mismatch");
+        const t = new Uint8Array(tlen);
+        let tp = 0;
+        const near = new Array(S_NEAR).fill(0), same = new Array(S_SAME * 256).fill(0);
+        let nextNear = 0;
+        const cache = (a) => { near[nextNear] = a; nextNear = (nextNear + 1) % S_NEAR; same[a % (S_SAME * 256)] = a; };
+        const decodeAddr = (here, mode) => {
+            let a;
+            if (mode === 0)
+                a = addr.int();
+            else if (mode === 1)
+                a = here - addr.int();
+            else if (mode - 2 < S_NEAR)
+                a = near[mode - 2] + addr.int();
+            else
+                a = same[(mode - 2 - S_NEAR) * 256 + addr.byte()];
+            cache(a);
+            return a;
+        };
+        const exec = (x) => {
+            if (x.type === NOOP)
+                return;
+            const size = x.size || inst.int();
+            if (tp + size > tlen)
+                throw new VcdiffError("vcdiff: instruction overruns the target window");
+            if (x.type === ADD) {
+                t.set(data.take(size), tp);
+                tp += size;
+                return;
+            }
+            if (x.type === RUN) {
+                t.fill(data.byte(), tp, tp + size);
+                tp += size;
+                return;
+            }
+            const a = decodeAddr(seg.length + tp, x.mode);
+            if (a < 0 || a >= seg.length + tp)
+                throw new VcdiffError("vcdiff: copy address out of range");
+            for (let k = 0; k < size; k++) {
+                const s = a + k;
+                t[tp++] = s < seg.length ? seg[s] : t[s - seg.length];
+            }
+        };
+        while (inst.at < inst.end) {
+            const [x, y] = TABLE[inst.byte()];
+            exec(x);
+            exec(y);
+        }
+        if (tp !== tlen || data.at !== data.end || addr.at !== addr.end)
+            throw new VcdiffError("vcdiff: window does not add up");
+        if (sum !== undefined && adler32(t) !== sum)
+            throw new VcdiffError("vcdiff: window checksum mismatch");
+        out.push(t);
+        target = Buffer.concat(out);
+    }
+    return new Uint8Array(Buffer.concat(out));
+}
+/**
+ * A minimal encoder (tests and `pack --patch`): one window over the whole
+ * source, the longest common prefix and suffix as COPYs, the middle as an ADD.
+ */
+export function vcdiffEncode(target, source = new Uint8Array(0)) {
+    const int = (v) => { const o = [v & 0x7f]; v = Math.floor(v / 128); while (v > 0) {
+        o.unshift((v & 0x7f) | 0x80);
+        v = Math.floor(v / 128);
+    } return o; };
+    let pre = 0;
+    while (pre < source.length && pre < target.length && source[pre] === target[pre])
+        pre++;
+    let suf = 0;
+    while (suf < source.length - pre && suf < target.length - pre && source[source.length - 1 - suf] === target[target.length - 1 - suf])
+        suf++;
+    const mid = target.subarray(pre, target.length - suf);
+    const inst = [], addr = [];
+    if (pre) {
+        inst.push(19, ...int(pre));
+        addr.push(...int(0));
+    } // COPY size 0 (explicit), mode 0 (VCD_SELF)
+    if (mid.length)
+        inst.push(1, ...int(mid.length)); // ADD size 0 (explicit)
+    if (suf) {
+        inst.push(19, ...int(suf));
+        addr.push(...int(source.length - suf));
+    }
+    const body = Buffer.concat([Buffer.from([...int(target.length), 0, ...int(mid.length), ...int(inst.length), ...int(addr.length)]), mid, Buffer.from(inst), Buffer.from(addr)]);
+    const win = source.length ? [0x01, ...int(source.length), ...int(0)] : [0x00];
+    return new Uint8Array(Buffer.concat([Buffer.from([0xd6, 0xc3, 0xc4, 0x00, 0x00, ...win, ...int(body.length)]), body]));
+}

package/dist/host/wasm-kernel.d.ts

@@ -0,0 +1,87 @@
+import { Worker } from "node:worker_threads";
+import type { CID } from "multiformats/cid";
+import { KernelSurface, type HostChainTip, type KernelOptions } from "./kernel.ts";
+/** The wasm kernel: $SKEIN_KERNEL_WASM, else kernel-zig's `zig build web` output (the package ships it there). */
+export declare const KERNEL_WASM: string;
+/** The pinned modules (the boundary programs): $SKEIN_WASM_DIR, else the repo's (the package's) wasm/. */
+export declare const WASM_DIR: string;
+/** One worker holding one machine: frames in, replies and the kernel's notices and requests out. */
+declare class Machine {
+    readonly worker: Worker;
+    private nextId;
+    private waiting;
+    readonly ready: Promise<void>;
+    readonly done: Promise<number>;
+    gone: boolean;
+    private control;
+    private ctrl;
+    private data;
+    constructor(module: WebAssembly.Module, w: {
+        db: string;
+        set: string;
+        mode: "instance" | "chain";
+        network?: string;
+    }, o: {
+        onNotify(op: string, v: Uint8Array): void;
+        onRequest(op: string, v: Uint8Array): Promise<Uint8Array>;
+        log?(line: string): void;
+    });
+    call(op: string, v?: unknown): Promise<unknown>;
+}
+export interface WasmHostOptions {
+    /** The host's network for the header chain (SKEIN_NETWORK: main, test, regtest; default main). */
+    network?: string;
+    log?(line: string): void;
+}
+/** The host's machines over one SQLite database (one per database per node process: acquire/release). */
+export declare class WasmHost {
+    private static all;
+    private static compiled?;
+    /** The wasm kernel, compiled once per node process. */
+    static module(): Promise<WebAssembly.Module>;
+    static acquire(db: string, o?: WasmHostOptions): WasmHost;
+    readonly db: string;
+    readonly o: WasmHostOptions;
+    private holders;
+    private views;
+    private chain?;
+    private recent;
+    private constructor();
+    /** Hydrate an instance: its machine on a worker of its own (the store's pinned modules installed). */
+    open(o: KernelOptions): Promise<WasmKernel>;
+    /** The host chain's holder (#156): a machine over the `host/chain` set, no instance. */
+    private holder;
+    /**
+     * #156: a run of headers into the host chain. The same run asked for again while it is in flight or
+     * just answered (every instance on one feed asks for the same event) is one call: its answer shared.
+     */
+    chainHeaders(raws: Uint8Array[]): Promise<HostChainTip>;
+    /** #156: an image's chain/headers (the tree `root`, whose blocks the set `set` holds) into the empty host chain. */
+    chainImport(set: string, root: CID): Promise<HostChainTip>;
+    /** #156: the host chain as it stands, or undefined (empty). */
+    chainTip(): Promise<HostChainTip | undefined>;
+    /** One holder less; the last stops every machine. */
+    release(): Promise<void>;
+}
+/** One instance's machine, as the router holds it. */
+export declare class WasmKernel extends KernelSurface {
+    readonly o: KernelOptions;
+    readonly host: WasmHost;
+    readonly machine: Machine;
+    private wire?;
+    /** Its stop has begun (the next open of the handle waits for the worker to end). */
+    stopping: boolean;
+    constructor(host: WasmHost, o: KernelOptions, module: WebAssembly.Module);
+    private onNotify;
+    get pid(): number | undefined;
+    call(op: string, v?: unknown): Promise<unknown>;
+    running(identity: string): Promise<void>;
+    /** #156: the host chain is the host's: its holder's. */
+    chainHeaders(raws: Uint8Array[]): Promise<HostChainTip>;
+    chainImport(root: CID): Promise<HostChainTip>;
+    chainTip(): Promise<HostChainTip | undefined>;
+    /** Stop the machine: what its worker runs finishes, its store is closed, the worker ends. */
+    stop(): Promise<void>;
+    exited(): Promise<void>;
+}
+export {};