@dcasegr/skein 0.0.0-stage → 0.1.1

package/dist/host/wasm-kernel.js

@@ -0,0 +1,296 @@
+// The host loads the machine (the settled split, 2026-10-31): the kernel as ONE
+// wasm module (kernel-zig/zig-out/web/skein-kernel.wasm — the same zig source
+// as the native binary), loaded in the host's own process: one machine per
+// ACTIVE instance on a node worker thread (wasm-worker.ts), one step at a time
+// on it, instances in parallel; an idle instance has no machine (the router's
+// idle stop ends its worker: it is its set on disk). Storage is the host's:
+// every instance a set of the host's one SQLite database (store-sqlite.ts);
+// `instances.store` = `sqlite:<db path>` (the set: the handle).
+//
+// `WasmHost` is one per database per node process (acquired and released as
+// `KernelHost` is): the compiled module, shared by every worker, and the host
+// chain's holder — one more worker over the `host/chain` set, with no
+// instance (#156: the header chain kept once; every instance reads it through
+// the chain exception). `WasmKernel` is an instance's machine with the
+// router's `KernelSurface`. The kernel's one blocking request, the signer
+// (`wallet`), is answered here on the main thread through the instance's
+// WalletWireProcessor (the wallet is asynchronous; the worker waits on a
+// SharedArrayBuffer). There is no `http`: #157.
+import { readFileSync } from "node:fs";
+import { dirname, extname, join, resolve as resolvePath } from "node:path";
+import { fileURLToPath } from "node:url";
+import { Worker } from "node:worker_threads";
+import { WalletWireProcessor } from "@bsv/sdk";
+import { decode, encode } from "../runtime/cid.js";
+import { CHAIN_SET, parseSqliteSpec } from "../runtime/index-store.js";
+import { Rejected } from "../runtime/store.js";
+import { KernelSurface } from "./kernel.js";
+const HERE = dirname(fileURLToPath(import.meta.url));
+const ROOT = resolvePath(HERE, "../..");
+/** The wasm kernel: $SKEIN_KERNEL_WASM, else kernel-zig's `zig build web` output (the package ships it there). */
+export const KERNEL_WASM = process.env.SKEIN_KERNEL_WASM || join(ROOT, "kernel-zig/zig-out/web/skein-kernel.wasm");
+/** The pinned modules (the boundary programs): $SKEIN_WASM_DIR, else the repo's (the package's) wasm/. */
+export const WASM_DIR = process.env.SKEIN_WASM_DIR || join(ROOT, "wasm");
+const WORKER = new URL(`./wasm-worker${extname(fileURLToPath(import.meta.url))}`, import.meta.url);
+/** One worker holding one machine: frames in, replies and the kernel's notices and requests out. */
+class Machine {
+    worker;
+    nextId = 1;
+    waiting = new Map();
+    ready;
+    done;
+    gone = false;
+    control = new SharedArrayBuffer(12);
+    ctrl = new Int32Array(this.control);
+    data = new SharedArrayBuffer(1 << 16, { maxByteLength: 1 << 30 });
+    constructor(module, w, o) {
+        this.worker = new Worker(WORKER, { workerData: { module, ...w, wasmDir: WASM_DIR, control: this.control, data: this.data } });
+        let ready, fail;
+        this.ready = new Promise((res, rej) => { ready = res; fail = rej; });
+        this.ready.catch(() => { });
+        this.worker.on("message", (m) => {
+            if (m.ready)
+                return ready();
+            if (m.re !== undefined) {
+                const p = this.waiting.get(m.re);
+                if (!p)
+                    return;
+                this.waiting.delete(m.re);
+                settle(p, decode(m.frame));
+                return;
+            }
+            if (m.notify !== undefined) {
+                try {
+                    o.onNotify(m.notify, m.v);
+                }
+                catch (e) {
+                    o.log?.(`router: ${m.notify}: ${e.message}`);
+                }
+                return;
+            }
+            if (m.request !== undefined) {
+                void (async () => {
+                    let status = 0, bytes;
+                    try {
+                        bytes = await o.onRequest(m.request, m.v);
+                    }
+                    catch (e) {
+                        status = 1;
+                        bytes = new TextEncoder().encode(e?.message ?? String(e));
+                    }
+                    if (bytes.length > this.data.byteLength)
+                        this.data.grow(bytes.length);
+                    new Uint8Array(this.data, 0, bytes.length).set(bytes);
+                    this.ctrl[1] = status;
+                    this.ctrl[2] = bytes.length;
+                    Atomics.store(this.ctrl, 0, 1);
+                    Atomics.notify(this.ctrl, 0);
+                })();
+            }
+        });
+        this.worker.on("error", (e) => { o.log?.(`kernel worker: ${e.message}`); fail(e); });
+        this.done = new Promise((res) => this.worker.once("exit", (code) => {
+            this.gone = true;
+            for (const p of this.waiting.values())
+                p.reject(new Error(`the kernel's worker exited (${code})`));
+            this.waiting.clear();
+            fail(new Error(`the kernel's worker exited (${code}) before it was ready`));
+            res(code);
+        }));
+    }
+    call(op, v) {
+        if (this.gone)
+            return Promise.reject(new Error("the kernel's worker is gone"));
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            this.waiting.set(id, { resolve, reject });
+            this.worker.postMessage({ id, frame: encode({ op, v: v ?? null }).bytes });
+        });
+    }
+}
+function settle(p, f) {
+    if (typeof f.rejected === "string")
+        p.reject(new Rejected(f.rejected, String(f.error)));
+    else if (typeof f.error === "string")
+        p.reject(new Error(f.error));
+    else
+        p.resolve(f.ok);
+}
+/** The host's machines over one SQLite database (one per database per node process: acquire/release). */
+export class WasmHost {
+    static all = new Map();
+    static compiled;
+    /** The wasm kernel, compiled once per node process. */
+    static module() {
+        WasmHost.compiled ??= WebAssembly.compile(readFileSync(KERNEL_WASM));
+        return WasmHost.compiled;
+    }
+    static acquire(db, o = {}) {
+        const key = resolvePath(db);
+        let h = WasmHost.all.get(key);
+        if (!h) {
+            h = new WasmHost(key, o);
+            WasmHost.all.set(key, h);
+        }
+        h.holders++;
+        return h;
+    }
+    db;
+    o;
+    holders = 0;
+    views = new Map();
+    chain;
+    recent = new Map();
+    constructor(db, o) { this.db = db; this.o = o; }
+    /** Hydrate an instance: its machine on a worker of its own (the store's pinned modules installed). */
+    async open(o) {
+        const p = parseSqliteSpec(o.db);
+        if (!p)
+            throw new Error(`kernel ${o.handle}: ${o.db} is not a SQLite set`);
+        if (p.set !== o.handle)
+            throw new Error(`kernel ${o.handle}: its SQLite set is its handle, not ${p.set}`);
+        if (resolvePath(p.db) !== this.db)
+            throw new Error(`kernel ${o.handle}: its database is ${p.db}, this host's ${this.db}`);
+        // A machine being stopped (an idle stop, a restart): its next open waits for its worker to end (KernelHost's `closing`).
+        const had = this.views.get(o.handle);
+        if (had && !had.gone) {
+            if (!had.stopping)
+                throw new Error(`kernel ${o.handle}: open already`);
+            await had.machine.done;
+        }
+        const k = new WasmKernel(this, o, await WasmHost.module());
+        this.views.set(o.handle, k);
+        try {
+            await k.machine.ready;
+        }
+        catch (e) {
+            this.views.delete(o.handle);
+            throw e;
+        }
+        void k.machine.done.then(() => { if (this.views.get(o.handle) === k)
+            this.views.delete(o.handle); });
+        return k;
+    }
+    /** The host chain's holder (#156): a machine over the `host/chain` set, no instance. */
+    holder() {
+        this.chain ??= (async () => {
+            const m = new Machine(await WasmHost.module(), { db: this.db, set: CHAIN_SET, mode: "chain", network: this.o.network ?? "main" }, {
+                onNotify: (op, v) => { if (op === "say" || op === "panic")
+                    this.o.log?.(`host chain: ${String(v)}`); },
+                onRequest: async (op) => { throw new Error(`the host chain asks no ${op}`); },
+                log: this.o.log,
+            });
+            await m.ready;
+            void m.done.then(() => { this.chain = undefined; });
+            return m;
+        })();
+        return this.chain;
+    }
+    /**
+     * #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) {
+        const key = raws.map((r) => Buffer.from(r).toString("hex")).join("");
+        const had = this.recent.get(key);
+        if (had)
+            return had;
+        const p = this.holder().then((m) => m.call("headers", { raws })).then(tipOf);
+        this.recent.set(key, p);
+        p.catch(() => this.recent.delete(key));
+        while (this.recent.size > 64)
+            this.recent.delete(this.recent.keys().next().value);
+        return p;
+    }
+    /** #156: an image's chain/headers (the tree `root`, whose blocks the set `set` holds) into the empty host chain. */
+    async chainImport(set, root) { return tipOf(await (await this.holder()).call("chain-import", { set, root })); }
+    /** #156: the host chain as it stands, or undefined (empty). */
+    async chainTip() { const v = await (await this.holder()).call("chain"); return v == null ? undefined : tipOf(v); }
+    /** One holder less; the last stops every machine. */
+    async release() {
+        if (--this.holders > 0)
+            return;
+        WasmHost.all.delete(this.db);
+        for (const k of [...this.views.values()])
+            await k.stop();
+        const c = await this.chain?.catch(() => undefined);
+        if (c && !c.gone) {
+            await c.call("stop").catch(() => { });
+            await c.done;
+        }
+    }
+}
+function tipOf(v) {
+    const o = v;
+    return { root: o.root, height: Number(o.height), hash: o.hash, ...(o.added !== undefined ? { added: Number(o.added) } : {}), ...(o.replaced !== undefined ? { replaced: Number(o.replaced) } : {}) };
+}
+/** One instance's machine, as the router holds it. */
+export class WasmKernel extends KernelSurface {
+    o;
+    host;
+    machine;
+    wire;
+    /** Its stop has begun (the next open of the handle waits for the worker to end). */
+    stopping = false;
+    constructor(host, o, module) {
+        super();
+        this.host = host;
+        this.o = o;
+        if (o.wallet)
+            this.wire = new WalletWireProcessor(o.wallet);
+        const set = parseSqliteSpec(o.db);
+        this.machine = new Machine(module, { db: set.db, set: set.set, mode: "instance" }, {
+            onNotify: (op, v) => this.onNotify(op, v),
+            onRequest: async (op, v) => {
+                if (op !== "wallet")
+                    throw new Error(`this host answers no ${op}`);
+                if (!this.wire)
+                    throw new Error("no wallet");
+                this.busy++;
+                // The request and its answer cross as dag-cbor (web.zig `request`: a byte string each way).
+                try {
+                    return encode(Uint8Array.from(await this.wire.transmitToWallet([...decode(v)]))).bytes;
+                }
+                finally {
+                    this.busy--;
+                    this.last = Date.now();
+                }
+            },
+            log: o.log,
+        });
+        void this.machine.done.then((code) => { this.gone = true; o.exited?.(code, null); });
+    }
+    onNotify(op, v) {
+        if (op === "emit") {
+            this.o.emit?.(decode(v));
+            return;
+        }
+        if (op === "say" || op === "panic")
+            this.o.log?.(String(v));
+    }
+    get pid() { return process.pid; }
+    call(op, v) {
+        this.busy++;
+        this.last = Date.now();
+        return this.machine.call(op, v).finally(() => { this.busy--; this.last = Date.now(); });
+    }
+    async running(identity) {
+        this.o.log?.(`skein runtime ${identity} (${this.o.handle}@${this.o.domain}) · wasm kernel, worker ${this.machine.worker.threadId} · db ${this.o.db}`);
+    }
+    /** #156: the host chain is the host's: its holder's. */
+    chainHeaders(raws) { return this.host.chainHeaders(raws); }
+    chainImport(root) { return this.host.chainImport(this.o.handle, root); }
+    chainTip() { return this.host.chainTip(); }
+    /** Stop the machine: what its worker runs finishes, its store is closed, the worker ends. */
+    async stop() {
+        if (this.gone || this.machine.gone)
+            return;
+        this.stopping = true;
+        try {
+            await this.machine.call("stop");
+        }
+        catch { /* it exited */ }
+        await this.machine.done;
+    }
+    exited() { return this.machine.done.then(() => { }); }
+}

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

@@ -0,0 +1 @@
+export {};

package/dist/host/wasm-worker.js

@@ -0,0 +1,186 @@
+// One machine (the settled split, 2026-10-31): a node worker thread holding
+// one wasm kernel (kernel-zig/zig-out/web/skein-kernel.wasm through the
+// dependency-free shim kernel-zig/web/kernel.js) for ONE active instance — or
+// the host's chain holder (#156: the header chain, kept once for the host). The
+// host's main thread never runs a program; one step at a time here; instances
+// in parallel on their own workers (wasm-kernel.ts).
+//
+// The kernel's store is a set of the host's one SQLite database (store-sqlite.ts,
+// this worker's own connection); the apps' wasm runs in the same V8 through the
+// shim's engine (the kernel names a module, the shim compiles and instantiates
+// it with imports that call back into the kernel). The kernel's blocking
+// request — the signer, `wallet` — goes to the main thread and this thread
+// waits for the answer (Atomics.wait on a SharedArrayBuffer, the browser
+// worker's way: kernel-zig/web/worker.js): the wallet the host holds the key
+// in is asynchronous. Its notices (emit, say, panic) are posted to the main
+// thread as they come.
+//
+// Messages in: {id, frame} (dag-cbor {op, v}) → {re: id, frame} (the reply:
+// dag-cbor {ok} | {error, rejected?}). After an admit or a start the worker
+// drains (the step loop) before it takes the next message, so the main
+// thread's next call sees what that ran. `answer` {entry, wait} answers once
+// the request entry's thread is at rest, or at its bound with the state as it
+// stands (serve's waiters, the same rule). `stop` closes the store and ends.
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { parentPort, workerData } from "node:worker_threads";
+import * as dagCbor from "@ipld/dag-cbor";
+import { Kernel } from "../../kernel-zig/web/kernel.js";
+import { openHostDb, SqliteSetStore } from "./store-sqlite.js";
+const d = workerData;
+const port = parentPort;
+const enc = new TextEncoder();
+const dec = new TextDecoder();
+const db = openHostDb(d.db);
+const stores = { 1: new SqliteSetStore(db, d.set) };
+const ctrl = new Int32Array(d.control); // [0] answered, [1] status (0 ok, 1 error), [2] length
+function request(op, v) {
+    Atomics.store(ctrl, 0, 0);
+    port.postMessage({ request: op, v });
+    Atomics.wait(ctrl, 0, 0);
+    const bytes = new Uint8Array(d.data, 0, ctrl[2]).slice();
+    return ctrl[1] === 0 ? { ok: bytes } : { error: dec.decode(bytes) };
+}
+let fatal = false;
+const kernel = new Kernel(d.module, {
+    stores,
+    peers: {
+        request,
+        notify: (op, v) => {
+            if (op === "panic")
+                fatal = true;
+            port.postMessage({ notify: op, v });
+        },
+    },
+});
+const reply = (v) => dagCbor.encode(v);
+if (d.mode === "chain") {
+    const net = kernel.push(d.network ?? "main");
+    try {
+        kernel.check(kernel.x.skein_open_chain(1, net[0], net[1]));
+    }
+    finally {
+        kernel.release(net);
+    }
+}
+else {
+    kernel.open(1);
+    // The pinned modules (the boundary programs), checked against their CIDs by the kernel (serve's install).
+    const mods = dagCbor.decode(kernel.modulesList());
+    for (const m of mods) {
+        if (stores[1].hasBlock(m.cid.bytes))
+            continue;
+        kernel.putBlock(m.cid.bytes, readFileSync(join(d.wasmDir, m.file)));
+    }
+}
+let waiters = [];
+let timer;
+function answerOf(entry) {
+    return kernel.call(dagCbor.encode({ op: "answer", v: entry }));
+}
+function atRest(r) {
+    const s = dagCbor.decode(r).ok?.state;
+    return s === "finished" || s === "errored";
+}
+/** Answer the waiters whose thread came to rest, or whose bound has passed. */
+function checkWaiters() {
+    const now = Date.now();
+    const keep = [];
+    for (const w of waiters) {
+        const r = answerOf(w.entry);
+        if (atRest(r) || w.until <= now)
+            port.postMessage({ re: w.id, frame: r });
+        else
+            keep.push(w);
+    }
+    waiters = keep;
+    if (timer) {
+        clearTimeout(timer);
+        timer = undefined;
+    }
+    if (waiters.length)
+        timer = setTimeout(checkWaiters, Math.max(0, Math.min(...waiters.map((w) => w.until)) - Date.now()));
+}
+// ------------------------------------------------------------ the main thread's calls
+function handle(id, f, raw) {
+    switch (f.op) {
+        case "admit": {
+            const r = kernel.admit(dagCbor.encode(f.v));
+            port.postMessage({ re: id, frame: r });
+            const ok = dagCbor.decode(r).ok;
+            if (ok && !(typeof ok === "object" && "answered" in ok)) {
+                kernel.drain();
+                checkWaiters();
+            }
+            return;
+        }
+        case "start": {
+            const r = kernel.start();
+            port.postMessage({ re: id, frame: r });
+            kernel.drain();
+            checkWaiters();
+            return;
+        }
+        case "drain": {
+            port.postMessage({ re: id, frame: kernel.drain() });
+            checkWaiters();
+            return;
+        }
+        case "answer": {
+            const v = f.v;
+            const r = answerOf(v.entry);
+            if (atRest(r) || Number(v.wait ?? 0) <= 0) {
+                port.postMessage({ re: id, frame: r });
+                return;
+            }
+            waiters.push({ id, entry: v.entry, until: Date.now() + Number(v.wait) });
+            checkWaiters();
+            return;
+        }
+        case "idle":
+            port.postMessage({ re: id, frame: reply({ ok: null }) });
+            return; // nothing runs between calls
+        case "chain-import": {
+            // #156: the image's chain/headers read from the instance's set (read only), as store 2.
+            const v = f.v;
+            stores[2] = new SqliteSetStore(db, v.set, { readOnly: true });
+            try {
+                port.postMessage({ re: id, frame: kernel.call(dagCbor.encode({ op: "chain-import", v: { root: v.root, store: 2 } })) });
+            }
+            finally {
+                delete stores[2];
+            }
+            return;
+        }
+        case "stop": {
+            if (timer)
+                clearTimeout(timer);
+            for (const w of waiters)
+                port.postMessage({ re: w.id, frame: answerOf(w.entry) });
+            waiters = [];
+            db.close();
+            port.postMessage({ re: id, frame: reply({ ok: null }) });
+            process.exit(0);
+        }
+        default:
+            port.postMessage({ re: id, frame: kernel.call(raw) });
+    }
+}
+port.on("message", (m) => {
+    const f = dagCbor.decode(m.frame);
+    try {
+        handle(m.id, f, m.frame);
+    }
+    catch (e) {
+        port.postMessage({ re: m.id, frame: reply({ error: `${f.op}: ${e?.message ?? String(e)}` }) });
+    }
+    if (fatal) {
+        try {
+            db.close();
+        }
+        catch { /* closing anyway */ }
+        process.exit(1);
+    }
+});
+port.postMessage({ ready: true });
+void enc;

package/dist/peers/cron.d.ts

@@ -0,0 +1,33 @@
+import type { Listed } from "../client/raw.ts";
+import { Cron, type ScheduleStore } from "../host/cron.ts";
+export interface CronPeerOptions {
+    /** Its mailbox instance (a RawBox as the service's key): requests arrive in box `cron`. */
+    inbox: {
+        list(box: string): Promise<Listed[]>;
+        ack(ids: string[]): Promise<void>;
+    };
+    /** A session with the messagebox at `url` (a RawBox as the service's key). */
+    outbox(url: string): {
+        send(recipient: string, box: string, body: unknown): Promise<unknown>;
+    };
+    /** Its address book: the messagebox URL of the sender `key`; undefined: no route. */
+    addressOf(key: string): string | undefined;
+    /** The clock (ms); default Date.now. */
+    now?(): number;
+    /** Where the schedules are kept (default memory). */
+    store?: ScheduleStore;
+    log?(line: string): void;
+}
+export declare class CronPeer {
+    readonly o: CronPeerOptions;
+    readonly cron: Cron;
+    private timer?;
+    private polling?;
+    constructor(o: CronPeerOptions);
+    private say;
+    /** Take up the kept schedules, and collect the `cron` box every `ms`. */
+    start(ms?: number): void;
+    stop(): Promise<void>;
+    /** Collect the `cron` box once: each request answered at its sender's messagebox, then acknowledged. How many were answered. */
+    poll(): Promise<number>;
+}

package/dist/peers/cron.js

@@ -0,0 +1,75 @@
+// A remote cron service (#69): the cron provider as a peer of its own,
+// reached by mailbox. An instance whose address book names the cron
+// provider's key with transport `mailbox` (its messagebox URL) emits its tick
+// requests exactly as it would to the host's own (`local`) cron provider:
+// the instance's delivery thread carries each over BRC-103/104 into the
+// service's mailbox instance; the program does not know which it talks to.
+//
+// The service collects its `cron` box there (raw BRC-33 on a BRC-104
+// session as its own key, like the inference peer: src/peers/infer.ts),
+// keeps the schedules (src/host/cron.ts: the same `Cron` the host's provider
+// runs; the instance is the sender's key) and answers each request — and
+// sends each tick — at the sender's messagebox, on a session of its own: a
+// message from the service's key, `replyTo` the request's id for an answer,
+// none for a tick. Where a sender's messagebox is comes from the service's
+// own address book (its admin's: `addressOf`); a request from a key it does
+// not know has nowhere to go and is dropped with one line.
+import { CID } from "multiformats/cid";
+import { Cron } from "../host/cron.js";
+const short = (s) => s.slice(-8);
+export class CronPeer {
+    o;
+    cron;
+    timer;
+    polling;
+    constructor(o) {
+        this.o = o;
+        this.cron = new Cron({
+            now: () => (o.now ?? Date.now)(), store: o.store, log: (_s, l) => this.say(l),
+            tick: async (s, body) => {
+                const url = this.o.addressOf(s.recipient);
+                if (!url)
+                    throw new Error(`no route to ${short(s.recipient)}`);
+                await this.o.outbox(url).send(s.recipient, s.box, body);
+            },
+        });
+    }
+    say(line) { this.o.log?.(line); }
+    /** Take up the kept schedules, and collect the `cron` box every `ms`. */
+    start(ms = 1000) {
+        this.cron.start();
+        const tick = () => { if (!this.polling)
+            this.polling = this.poll().catch((e) => this.say(`cron: ${e.message}`)).finally(() => { this.polling = undefined; }); };
+        tick();
+        this.timer = setInterval(tick, ms);
+    }
+    async stop() {
+        if (this.timer)
+            clearInterval(this.timer);
+        await this.polling;
+        await this.cron.stop();
+    }
+    /** Collect the `cron` box once: each request answered at its sender's messagebox, then acknowledged. How many were answered. */
+    async poll() {
+        let n = 0;
+        for (const m of await this.o.inbox.list("cron")) {
+            const url = this.o.addressOf(m.sender);
+            if (!url) {
+                this.say(`cron ${short(m.messageId)} from ${short(m.sender)}: no route: ${m.sender} is not in the address book; dropped`);
+                await this.o.inbox.ack([m.messageId]);
+                continue;
+            }
+            const answer = this.cron.request(m.sender, m.sender, m.messageId, m.value);
+            try {
+                await this.o.outbox(url).send(m.sender, "cron", { replyTo: CID.parse(m.messageId), ...answer });
+                n++;
+            }
+            catch (e) {
+                this.say(`cron ${short(m.messageId)}: answer to ${url}: ${e.message} (left unacknowledged)`);
+                continue;
+            }
+            await this.o.inbox.ack([m.messageId]);
+        }
+        return n;
+    }
+}

package/dist/peers/infer-main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env -S node --experimental-strip-types --no-warnings
+export {};

package/dist/peers/infer-main.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env -S node --experimental-strip-types --no-warnings
+// `skein-infer`: the inference peer process (infer.ts). Its environment
+// (bin/skein-infer fills it from ~/.skein):
+//   SKEIN_INFER_WALLET_URL  its BRC-100 wallet, default http://127.0.0.1:3323 (`1sat serve wallet-api`), origin "skein-infer"
+//   SKEIN_MAILBOX_URL       its mailbox instance (#40), e.g. http://infer.localhost:8100 or http://127.0.0.1:8100/@infer
+//   SKEIN_INFER_PEERS       its address book (#40): {"<identity key hex>": "<messagebox URL>", …}, default
+//                           $SKEIN_HOME/infer-peers.json (scripts/host/up.sh writes every agent's); read again
+//                           when it changes. A request from a key not in it has nowhere to go: dropped, one line.
+//   SKEIN_INFER_PROVIDERS   the provider map file, default $SKEIN_HOME/infer.json
+//   SKEIN_INFER_HANDLE      its handle, default infer@localhost
+//   SKEIN_INFER_CACHE       its conversation graph on disk (issue #12), default $SKEIN_HOME/infer-cache;
+//                           "" keeps it in memory only
+//   SKEIN_INFER_NODES       how many nodes it holds in memory, default 50000
+//   SKEIN_POLL_MS           default 1000
+import { readFileSync, statSync } from "node:fs";
+import { RawBox } from "../client/raw.js";
+import { connectWallet } from "../wallet.js";
+import { InferPeer, NodeGraph } from "./infer.js";
+const env = process.env;
+const home = env.SKEIN_HOME || `${env.HOME}/.skein`;
+const say = (line) => process.stdout.write(`${line}\n`);
+const die = (msg) => { process.stderr.write(`skein-infer: ${msg}\n`); process.exit(1); };
+const providersFile = env.SKEIN_INFER_PROVIDERS || `${home}/infer.json`;
+let providers;
+try {
+    providers = JSON.parse(readFileSync(providersFile, "utf8"));
+}
+catch (e) {
+    die(`${providersFile}: ${e.message}`);
+}
+if (!env.SKEIN_MAILBOX_URL)
+    die("SKEIN_MAILBOX_URL is not set (its mailbox instance: skein-host add infer --mailbox --owner <its key>)");
+const wallet = await connectWallet({ kind: "remote", url: env.SKEIN_INFER_WALLET_URL || "http://127.0.0.1:3323", originator: "skein-infer" });
+const { publicKey } = await wallet.getPublicKey({ identityKey: true });
+const cache = env.SKEIN_INFER_CACHE ?? `${home}/infer-cache`;
+const graph = new NodeGraph({ dir: cache || undefined, max: env.SKEIN_INFER_NODES ? Number(env.SKEIN_INFER_NODES) : undefined });
+const peersFile = env.SKEIN_INFER_PEERS || `${home}/infer-peers.json`;
+let book = { mtime: -1, peers: {} };
+/** The address book, read again when the file changed (the admin edits it; up.sh rewrites it). */
+const addressOf = (key) => {
+    let mtime = 0;
+    try {
+        mtime = statSync(peersFile).mtimeMs;
+    }
+    catch { /* none: an empty book */ }
+    if (mtime !== book.mtime) {
+        try {
+            book = { mtime, peers: mtime ? JSON.parse(readFileSync(peersFile, "utf8")) : {} };
+        }
+        catch (e) {
+            say(`${peersFile}: ${e.message}`);
+            book = { mtime, peers: {} };
+        }
+    }
+    const url = book.peers[key];
+    return typeof url === "string" && url ? url : undefined;
+};
+const outboxes = new Map();
+const peer = new InferPeer({
+    graph, wallet, providers: providers, handle: env.SKEIN_INFER_HANDLE, log: say,
+    raw: {
+        inbox: new RawBox(wallet, env.SKEIN_MAILBOX_URL, { originator: "skein-infer" }),
+        outbox: (url) => { let b = outboxes.get(url); if (!b) {
+            b = new RawBox(wallet, url, { originator: "skein-infer" });
+            outboxes.set(url, b);
+        } return b; },
+        addressOf,
+    },
+});
+peer.start(Number(env.SKEIN_POLL_MS || 1000));
+say(`skein-infer ${publicKey} · providers ${Object.keys(providers).join(",")} · mailbox ${env.SKEIN_MAILBOX_URL} · graph ${cache || "in memory"} · address book ${peersFile}`);
+const stop = async (sig) => { say(`${sig}: stopping`); await peer.stop(); process.exit(0); };
+process.once("SIGINT", () => void stop("SIGINT"));
+process.once("SIGTERM", () => void stop("SIGTERM"));