@dcasegr/skein 0.0.0-stage → 0.1.2

package/dist/runtime/bitcoin.d.ts

@@ -0,0 +1,36 @@
+import { CID } from "multiformats/cid";
+export declare const BITCOIN_BLOCK = 176, BITCOIN_TX = 177, DBL_SHA2_256 = 86;
+export declare const hashCid: (code: number, h: Uint8Array) => CID<unknown, number, 86, 1>;
+export declare const displayHash: (h: Uint8Array) => string;
+export declare const isBitcoin: (c: CID) => boolean;
+export interface Input {
+    prev: Uint8Array;
+    vout: number;
+    script: Uint8Array;
+    sequence: number;
+}
+export interface Output {
+    value: bigint;
+    script: Uint8Array;
+}
+export interface Tx {
+    version: number;
+    inputs: Input[];
+    outputs: Output[];
+    locktime: number;
+}
+/** A transaction's standard serialization (no segwit: BSV); throws when malformed. */
+export declare function parseTx(b: Uint8Array): Tx;
+/** The typed node for a bitcoin block's bytes; undefined when it is not one (or does not decode). */
+export declare function decodeBitcoin(cid: CID, b: Uint8Array): unknown;
+export interface BitcoinLink {
+    to: CID;
+    rel: string;
+    locator: number | null;
+}
+/** The links a bitcoin block holds, in order (kernel-zig/src/bitcoin.zig `links`); none when it is not one or does not decode. */
+export declare function bitcoinLinks(cid: CID, b: Uint8Array): BitcoinLink[];
+/** The edges a kept bitcoin block contributes (kernel-zig/src/bitcoin.zig `edgesOf`): a transaction's `spends` links; none for a header or a merkle node. */
+export declare function bitcoinEdges(cid: CID, b: Uint8Array): BitcoinLink[];
+/** What a bitcoin block is, for display. */
+export declare function bitcoinKind(cid: CID, b: Uint8Array): "header" | "merkle node" | "transaction" | undefined;

package/dist/runtime/bitcoin.js

@@ -0,0 +1,141 @@
+// Bitcoin blocks decoded the IPLD way (issue #42) — the TypeScript twin of
+// kernel-zig/src/bitcoin.zig, for the readers (the explorer, packets, the
+// index derivation in index-store.ts). All dbl-sha2-256, the hash in internal
+// byte order:
+//
+//   bitcoin-block (0xb0), an 80-byte header:
+//     {version, previousblockhash → link(bitcoin-block) | null (genesis),
+//      merkleroot → link(bitcoin-tx), time, bits, nonce}
+//   bitcoin-tx (0xb1), a transaction:
+//     {version, vin: [{txid → link(bitcoin-tx), vout, script, sequence} | {coinbase, sequence}],
+//      vout: [{value, script}], locktime}
+//   bitcoin-tx (0xb1), exactly 64 bytes: a merkle tree node [left → link, right → link]
+//     (IPLD's convention: a 64-byte transaction is malformed by convention, so
+//     64 bytes always reads as a node)
+//
+// Forward links (`bitcoinLinks`, what packets and the explorer follow):
+// inputs → the spent txid, rel `spends`, locator = vout (a coinbase input
+// links nothing); header → `prev`, `merkleroot`; merkle node → `child`,
+// locator 0 / 1. Edges (`bitcoinEdges`, what a kept block contributes to the
+// index, index.zig; #42 decided 2026-09-30): a transaction's inputs only —
+// headers and merkle nodes contribute none.
+import { CID } from "multiformats/cid";
+import * as Digest from "multiformats/hashes/digest";
+export const BITCOIN_BLOCK = 0xb0, BITCOIN_TX = 0xb1, DBL_SHA2_256 = 0x56;
+export const hashCid = (code, h) => CID.createV1(code, Digest.create(DBL_SHA2_256, Uint8Array.from(h)));
+export const displayHash = (h) => Buffer.from(h).reverse().toString("hex");
+export const isBitcoin = (c) => (c.code === BITCOIN_BLOCK || c.code === BITCOIN_TX) && c.multihash.code === DBL_SHA2_256;
+const isNull = (h) => h.every((b) => b === 0);
+/** A transaction's standard serialization (no segwit: BSV); throws when malformed. */
+export function parseTx(b) {
+    const dv = new DataView(b.buffer, b.byteOffset, b.byteLength);
+    let i = 0;
+    const need = (n) => { if (n > b.length - i)
+        throw new Error("malformed transaction"); };
+    const u32 = () => { need(4); const v = dv.getUint32(i, true); i += 4; return v; };
+    const u64 = () => { need(8); const v = dv.getBigUint64(i, true); i += 8; return v; };
+    const varint = () => {
+        need(1);
+        const f = b[i++];
+        if (f === 0xfd) {
+            need(2);
+            const v = dv.getUint16(i, true);
+            i += 2;
+            return v;
+        }
+        if (f === 0xfe)
+            return u32();
+        if (f === 0xff)
+            return Number(u64());
+        return f;
+    };
+    const bytes = () => { const n = varint(); need(n); const v = b.subarray(i, i + n); i += n; return v; };
+    const take = (n) => { need(n); const v = b.subarray(i, i + n); i += n; return v; };
+    const version = u32() | 0;
+    const nin = varint();
+    if (nin > (b.length - i) / 41)
+        throw new Error("malformed transaction");
+    const inputs = [];
+    for (let k = 0; k < nin; k++)
+        inputs.push({ prev: take(32), vout: u32(), script: bytes(), sequence: u32() });
+    const nout = varint();
+    if (nout > (b.length - i) / 9)
+        throw new Error("malformed transaction");
+    const outputs = [];
+    for (let k = 0; k < nout; k++)
+        outputs.push({ value: u64(), script: bytes() });
+    const locktime = u32();
+    if (i !== b.length)
+        throw new Error("malformed transaction");
+    return { version, inputs, outputs, locktime };
+}
+const isCoinbase = (x) => x.vout === 0xffffffff && isNull(x.prev);
+/** The typed node for a bitcoin block's bytes; undefined when it is not one (or does not decode). */
+export function decodeBitcoin(cid, b) {
+    if (!isBitcoin(cid))
+        return undefined;
+    if (cid.code === BITCOIN_BLOCK) {
+        if (b.length !== 80)
+            return undefined;
+        const dv = new DataView(b.buffer, b.byteOffset, 80);
+        return {
+            version: dv.getInt32(0, true),
+            previousblockhash: isNull(b.subarray(4, 36)) ? null : hashCid(BITCOIN_BLOCK, b.subarray(4, 36)),
+            merkleroot: hashCid(BITCOIN_TX, b.subarray(36, 68)),
+            time: dv.getUint32(68, true),
+            bits: dv.getUint32(72, true),
+            nonce: dv.getUint32(76, true),
+        };
+    }
+    if (b.length === 64)
+        return [hashCid(BITCOIN_TX, b.subarray(0, 32)), hashCid(BITCOIN_TX, b.subarray(32, 64))];
+    let tx;
+    try {
+        tx = parseTx(b);
+    }
+    catch {
+        return undefined;
+    } // not a transaction: no fields (the explorer shows the raw block)
+    return {
+        version: tx.version,
+        vin: tx.inputs.map((x) => isCoinbase(x) ? { coinbase: x.script, sequence: x.sequence } : { txid: hashCid(BITCOIN_TX, x.prev), vout: x.vout, script: x.script, sequence: x.sequence }),
+        vout: tx.outputs.map((o) => ({ value: Number(o.value), script: o.script })),
+        locktime: tx.locktime,
+    };
+}
+/** The links a bitcoin block holds, in order (kernel-zig/src/bitcoin.zig `links`); none when it is not one or does not decode. */
+export function bitcoinLinks(cid, b) {
+    if (!isBitcoin(cid))
+        return [];
+    if (cid.code === BITCOIN_BLOCK) {
+        if (b.length !== 80)
+            return [];
+        const out = [];
+        if (!isNull(b.subarray(4, 36)))
+            out.push({ to: hashCid(BITCOIN_BLOCK, b.subarray(4, 36)), rel: "prev", locator: null });
+        out.push({ to: hashCid(BITCOIN_TX, b.subarray(36, 68)), rel: "merkleroot", locator: null });
+        return out;
+    }
+    if (b.length === 64)
+        return [0, 1].map((k) => ({ to: hashCid(BITCOIN_TX, b.subarray(32 * k, 32 * k + 32)), rel: "child", locator: k }));
+    try {
+        return parseTx(b).inputs.filter((x) => !isCoinbase(x)).map((x) => ({ to: hashCid(BITCOIN_TX, x.prev), rel: "spends", locator: x.vout }));
+    }
+    catch {
+        return [];
+    } // does not decode: no links, as the doc says
+}
+/** The edges a kept bitcoin block contributes (kernel-zig/src/bitcoin.zig `edgesOf`): a transaction's `spends` links; none for a header or a merkle node. */
+export function bitcoinEdges(cid, b) {
+    if (!isBitcoin(cid) || cid.code !== BITCOIN_TX || b.length === 64)
+        return [];
+    return bitcoinLinks(cid, b);
+}
+/** What a bitcoin block is, for display. */
+export function bitcoinKind(cid, b) {
+    if (!isBitcoin(cid))
+        return undefined;
+    if (cid.code === BITCOIN_BLOCK)
+        return b.length === 80 ? "header" : undefined;
+    return b.length === 64 ? "merkle node" : "transaction";
+}

package/dist/runtime/cid.d.ts

@@ -0,0 +1,14 @@
+import { CID } from "multiformats/cid";
+export { CID };
+/** Encode a value as a dag-cbor block. Undefined properties are dropped (not an IPLD type). */
+export declare function encode(value: unknown): {
+    cid: CID;
+    bytes: Uint8Array;
+};
+export declare function decode<T = unknown>(bytes: Uint8Array): T;
+/** Accepts any multibase the CID parser knows; base32 (`bafy…`) is what we emit. */
+export declare function parse(s: string): CID;
+export declare function fmt(cid: CID): string;
+/** CID from its binary form (how the index stores them). */
+export declare function fromBytes(bytes: Uint8Array): CID;
+export declare function isCID(x: unknown): x is CID;

package/dist/runtime/cid.js

@@ -0,0 +1,51 @@
+// CID helpers. Blocks are dag-cbor, hashed sha2-256, identified by CIDv1.
+// Everything here is synchronous on purpose: the store encodes inside its
+// write transactions, and an await there would let appends interleave.
+import { createHash } from "node:crypto";
+import * as dagCbor from "@ipld/dag-cbor";
+import { CID } from "multiformats/cid";
+import * as Digest from "multiformats/hashes/digest";
+export { CID };
+const SHA2_256 = 0x12;
+/** Encode a value as a dag-cbor block. Undefined properties are dropped (not an IPLD type). */
+export function encode(value) {
+    const bytes = dagCbor.encode(strip(value));
+    const digest = Digest.create(SHA2_256, createHash("sha256").update(bytes).digest());
+    return { cid: CID.createV1(dagCbor.code, digest), bytes };
+}
+export function decode(bytes) {
+    return dagCbor.decode(bytes);
+}
+/** Accepts any multibase the CID parser knows; base32 (`bafy…`) is what we emit. */
+export function parse(s) {
+    return CID.parse(s);
+}
+export function fmt(cid) {
+    return cid.toString();
+}
+/** CID from its binary form (how the index stores them). */
+export function fromBytes(bytes) {
+    return CID.decode(bytes);
+}
+export function isCID(x) {
+    return CID.asCID(x) !== null;
+}
+// Callers build update bodies with optional fields left undefined; dag-cbor
+// rejects undefined outright. Only plain objects are rewritten — CIDs, bytes
+// and arrays pass through (undefined inside an array is still an error).
+function strip(v) {
+    if (v === null || typeof v !== "object")
+        return v;
+    if (Array.isArray(v))
+        return v.map(strip);
+    if (CID.asCID(v) || ArrayBuffer.isView(v))
+        return v;
+    const proto = Object.getPrototypeOf(v);
+    if (proto !== Object.prototype && proto !== null)
+        return v;
+    const out = {};
+    for (const [k, x] of Object.entries(v))
+        if (x !== undefined)
+            out[k] = strip(x);
+    return out;
+}

package/dist/runtime/dispatch.d.ts

@@ -0,0 +1,92 @@
+import { CID } from "multiformats/cid";
+import { type Store } from "./store.ts";
+import type { Ms } from "./types.ts";
+export type DispatchOrigin = {
+    kind: "dispatch";
+};
+export type Op = "add" | "remove";
+export type Transport = "mailbox" | "event" | "http" | "libp2p" | "local";
+/** A route as the kernel holds it; `program` a program record's CID, "kernel" (an admin operation named by `fn`), or absent (a read route). */
+export type DispatchRow = {
+    transport: Transport;
+    address: string;
+    prefix?: boolean;
+    filters?: string[];
+    program?: CID | "kernel";
+    fn?: string;
+    app?: string;
+    [setting: string]: unknown;
+};
+export type DispatchUpdate = {
+    op: Op;
+    row: DispatchRow;
+    origin: CID;
+    prev: CID;
+    seq: number;
+    thread?: CID;
+    input: CID;
+    at: Ms;
+};
+/** The kernel's own filters (kernel-zig door.zig). */
+export declare const KERNEL_FILTERS: readonly ["kernel.brc104", "kernel.beef"];
+/** The chain's origin: the same CID in every store. */
+export declare const dispatchOrigin: () => CID;
+/**
+ * A route's key as text: (transport, address, prefix), space-separated with the word `prefix` for a
+ * prefix route. No address has a space, so the texts of two keys are equal only when the keys are
+ * (dispatch.zig `sameKey`).
+ */
+export declare const rowKey: (r: {
+    transport: string;
+    address: string;
+    prefix?: boolean;
+}) => string;
+/** Whether `s` names a filter (dispatch.zig isFilterRef): one of the kernel's, or `<app>.<filter>`. */
+export declare function isFilterRef(s: unknown): s is string;
+/**
+ * Whether the kernel's fold keeps `r` (dispatch.zig `rowOf`): a map with a text transport and
+ * address, no sender, and a program that is text, a CID, or absent. What the kernel's `problem`
+ * refuses never reaches a chain; this is what the fold itself drops.
+ */
+export declare function isFoldable(r: unknown): r is DispatchRow;
+/** Whether a route is a read route (#143): filters only, no handler. */
+export declare const isReadRoute: (r: DispatchRow) => boolean;
+/** The routes after `updates`, in order (dispatch.zig `fold`: an update with no op or a route the kernel does not read is skipped). */
+export declare function fold(updates: Iterable<{
+    op: Op;
+    row: DispatchRow;
+}>): DispatchRow[];
+/** The chain's updates, oldest first; undefined if the chain was never opened (no genesis processed). */
+export declare function dispatchUpdates(store: Store): Promise<Array<{
+    cid: CID;
+    u: DispatchUpdate;
+}> | undefined>;
+/** The routes now; undefined if the chain was never opened. */
+export declare function currentDispatch(store: Store): Promise<DispatchRow[] | undefined>;
+/** Whether a mailbox route takes a message in `box` (dispatch.zig forMail). */
+export declare const takesMail: (r: DispatchRow, box: string) => boolean;
+/** Whether an event route takes an event in `box` (dispatch.zig forEvent). */
+export declare const takesEvent: (r: DispatchRow, box: string) => boolean;
+/** The first route a message in `box` routes to, with its index, or undefined (dispatch.zig forMail). */
+export declare const forMail: (rows: DispatchRow[], box: string) => {
+    i: number;
+    row: DispatchRow;
+} | undefined;
+/** The first route an event in `box` routes to (dispatch.zig forEvent). */
+export declare const forEvent: (rows: DispatchRow[], box: string) => {
+    i: number;
+    row: DispatchRow;
+} | undefined;
+/** A request's http route (dispatch.zig forHttp): the exact path first, then the longest prefix the path starts with. */
+export declare function forHttp(rows: DispatchRow[], path: string): {
+    i: number;
+    row: DispatchRow;
+} | undefined;
+/**
+ * A libp2p package's route (dispatch.zig forLibp2p): the `libp2p` route at its topic or
+ * `/<protocol>` exactly. A topic no route is at may be delivered by an app's subscription (#119, the kernel's).
+ */
+export declare const forLibp2p: (rows: DispatchRow[], name: string) => {
+    i: number;
+    row: DispatchRow;
+} | undefined;

package/dist/runtime/dispatch.js

@@ -0,0 +1,142 @@
+// The route table (#77, #143; docs/MESSAGES.md "The dispatch table"), read
+// from a store: one of the kernel's tables, the one that routes. Routing only
+// (#143: no sender — who may run a function is the grants', kernel-zig
+// grants.zig). One chain per instance, origin
+//
+//   { kind: "dispatch" }
+//
+// and one update per change, { op: "add" | "remove", row, thread?, input, at }
+// (the store adds origin, prev, seq). The routes are the updates folded in
+// order: a route's key is (transport, address, prefix); `add` replaces the
+// route with that key in place, else appends; `remove` deletes it.
+//
+//   route  {transport: "mailbox" | "event" | "http" | "libp2p" | "local", address, prefix?: true (http only),
+//           filters?: ["kernel.brc104" | "kernel.beef" | "<app>.<filter>"], program?: <cid> | "kernel", fn?, app?,
+//           …settings}
+//
+//   No program: a read route (http only) — its filters answer, nothing is logged. `event` (#143): events
+//   are their own transport (the host's wiring into a box), never a message.
+//
+// The kernel writes the chain and matches by it (kernel-zig/src/dispatch.zig):
+// the genesis's `dispatch` as its first updates (no `thread`), then a change
+// whenever its `dispatch` operation takes an admin message. Here it is read —
+// by the host (the libp2p node's topics, whether an instance takes a box, the
+// install client), the explorer, and tests — and matched with the kernel's
+// rules: kernel-zig/test/dispatch-cases.json holds the cases both this file
+// (dispatch.test.ts) and dispatch.zig are checked against.
+import { CID } from "multiformats/cid";
+import { encode } from "./cid.js";
+import { NotFound } from "./store.js";
+const ORIGIN = { kind: "dispatch" };
+/** The kernel's own filters (kernel-zig door.zig). */
+export const KERNEL_FILTERS = ["kernel.brc104", "kernel.beef"];
+/** The chain's origin: the same CID in every store. */
+export const dispatchOrigin = () => encode(ORIGIN).cid;
+/**
+ * A route's key as text: (transport, address, prefix), space-separated with the word `prefix` for a
+ * prefix route. No address has a space, so the texts of two keys are equal only when the keys are
+ * (dispatch.zig `sameKey`).
+ */
+export const rowKey = (r) => `${r.transport} ${r.address}${r.prefix === true ? " prefix" : ""}`;
+const isCid = (x) => CID.asCID(x) !== null;
+/** Whether `s` names a filter (dispatch.zig isFilterRef): one of the kernel's, or `<app>.<filter>`. */
+export function isFilterRef(s) {
+    if (typeof s !== "string")
+        return false;
+    const dot = s.lastIndexOf(".");
+    if (dot <= 0)
+        return false;
+    const app = s.slice(0, dot), name = s.slice(dot + 1);
+    if (!/^[A-Za-z0-9_-]+$/.test(name) || /[\s\0/]/.test(app))
+        return false;
+    return app === "kernel" ? KERNEL_FILTERS.includes(s) : true;
+}
+/**
+ * Whether the kernel's fold keeps `r` (dispatch.zig `rowOf`): a map with a text transport and
+ * address, no sender, and a program that is text, a CID, or absent. What the kernel's `problem`
+ * refuses never reaches a chain; this is what the fold itself drops.
+ */
+export function isFoldable(r) {
+    if (typeof r !== "object" || r === null || Array.isArray(r) || r instanceof Uint8Array)
+        return false;
+    const x = r;
+    if (typeof x.transport !== "string" || typeof x.address !== "string")
+        return false;
+    if (x.sender !== undefined)
+        return false;
+    if (x.program === undefined)
+        return true;
+    return x.program === "kernel" || isCid(x.program);
+}
+/** Whether a route is a read route (#143): filters only, no handler. */
+export const isReadRoute = (r) => r.program === undefined;
+/** The routes after `updates`, in order (dispatch.zig `fold`: an update with no op or a route the kernel does not read is skipped). */
+export function fold(updates) {
+    const out = [];
+    for (const u of updates) {
+        if (typeof u.op !== "string" || !isFoldable(u.row))
+            continue;
+        const i = out.findIndex((r) => rowKey(r) === rowKey(u.row));
+        if (u.op === "add") {
+            if (i < 0)
+                out.push(u.row);
+            else
+                out[i] = u.row;
+        }
+        if (u.op === "remove" && i >= 0)
+            out.splice(i, 1);
+    }
+    return out;
+}
+/** The chain's updates, oldest first; undefined if the chain was never opened (no genesis processed). */
+export async function dispatchUpdates(store) {
+    const origin = dispatchOrigin();
+    const out = [];
+    try {
+        await store.chains.tip(origin);
+    }
+    catch (e) {
+        if (e instanceof NotFound)
+            return undefined;
+        throw e;
+    }
+    for await (const c of store.chains.history(origin))
+        if (!c.equals(origin))
+            out.push({ cid: c, u: await store.get(c) });
+    return out;
+}
+/** The routes now; undefined if the chain was never opened. */
+export async function currentDispatch(store) {
+    const ups = await dispatchUpdates(store);
+    return ups && fold(ups.map((x) => x.u));
+}
+// ---------------------------------------------------------------- the match (dispatch.zig, the same rules)
+const found = (rows, i) => i < 0 ? undefined : { i, row: rows[i] };
+const atBox = (r, box) => r.address === "*" || r.address === box;
+/** Whether a mailbox route takes a message in `box` (dispatch.zig forMail). */
+export const takesMail = (r, box) => r.transport === "mailbox" && atBox(r, box);
+/** Whether an event route takes an event in `box` (dispatch.zig forEvent). */
+export const takesEvent = (r, box) => r.transport === "event" && atBox(r, box);
+/** The first route a message in `box` routes to, with its index, or undefined (dispatch.zig forMail). */
+export const forMail = (rows, box) => found(rows, rows.findIndex((r) => takesMail(r, box)));
+/** The first route an event in `box` routes to (dispatch.zig forEvent). */
+export const forEvent = (rows, box) => found(rows, rows.findIndex((r) => takesEvent(r, box)));
+/** A request's http route (dispatch.zig forHttp): the exact path first, then the longest prefix the path starts with. */
+export function forHttp(rows, path) {
+    const exact = rows.findIndex((r) => r.transport === "http" && r.prefix !== true && r.address === path);
+    if (exact >= 0)
+        return found(rows, exact);
+    let best = -1;
+    rows.forEach((r, i) => {
+        if (r.transport !== "http" || r.prefix !== true || !path.startsWith(r.address))
+            return;
+        if (best < 0 || r.address.length > rows[best].address.length)
+            best = i;
+    });
+    return found(rows, best);
+}
+/**
+ * A libp2p package's route (dispatch.zig forLibp2p): the `libp2p` route at its topic or
+ * `/<protocol>` exactly. A topic no route is at may be delivered by an app's subscription (#119, the kernel's).
+ */
+export const forLibp2p = (rows, name) => found(rows, rows.findIndex((r) => r.transport === "libp2p" && r.prefix !== true && r.address === name));

package/dist/runtime/envelope.d.ts

@@ -0,0 +1,60 @@
+import type { WalletProtocol } from "@bsv/sdk";
+export declare const ENVELOPE_PROTOCOL: [2, "metanet handles envelope"];
+export declare const ENVELOPE_KEY_ID = "send";
+export declare const MESSAGE_ENCRYPTION: WalletProtocol;
+export declare const BRC78_VERSION: Uint8Array<ArrayBuffer>;
+export interface Envelope {
+    metanetHandles: "1.0";
+    recipient: {
+        handle: string;
+        tag?: string;
+        domain: string;
+    };
+    sender: {
+        identityKey: string;
+        handle?: string;
+        domain?: string;
+    };
+    created: string;
+    quoteId?: string;
+    payment?: unknown;
+    contentHash: string;
+    content: string;
+    signature: string;
+}
+/** The sender-signed part: the envelope without its wire encryption. What an instance keeps. */
+export type Signed = Omit<Envelope, "content">;
+export declare function signedPart(env: Envelope | Signed): Signed;
+/** hex SHA-256 of the plaintext content. */
+export declare const contentHash: (body: Uint8Array) => string;
+/**
+ * RFC 8785 (JCS) canonical JSON of the envelope without `content` and
+ * `signature`: keys sorted by UTF-16 code units, no whitespace, strings and
+ * numbers as ECMAScript JSON.stringify writes them (which is what JCS
+ * specifies). Undefined members are omitted.
+ */
+export declare function canonical(env: Partial<Envelope>): string;
+export declare function jcs(v: unknown): string;
+export interface Brc78 {
+    version: Uint8Array;
+    sender: string;
+    recipient: string;
+    keyId: Uint8Array;
+    ciphertext: Uint8Array;
+}
+export declare function brc78Encode(m: {
+    sender: string;
+    recipient: string;
+    keyId: Uint8Array;
+    ciphertext: Uint8Array;
+}): Uint8Array;
+export declare function brc78Decode(bytes: Uint8Array): Brc78;
+/**
+ * The signature against sender.identityKey, with no wallet: the signing key is
+ * derived per BRC-42 (invoice "2-metanet handles envelope-1", counterparty
+ * anyone). Also checks the shape, and, when `content` is present, that the
+ * BRC-78 content names the same sender. Works on the signed part alone.
+ */
+export declare function verify(env: Envelope | Signed): boolean;
+export declare function isSigned(x: unknown): x is Signed;
+export declare function isEnvelope(x: unknown): x is Envelope;

package/dist/runtime/envelope.js

@@ -0,0 +1,101 @@
+// BRC-169 §7.2 envelopes: the shape and the checks that need no wallet —
+// the signed part, contentHash, RFC 8785 canonical form, BRC-78 framing, the
+// signature against sender.identityKey. src/envelope.ts adds the wallet
+// operations (sign, encrypt, open) for the client and the peers. See
+// src/envelope.ts for the wire format.
+import { createHash } from "node:crypto";
+import { verifyAnyone } from "./identity.js";
+export const ENVELOPE_PROTOCOL = [2, "metanet handles envelope"];
+export const ENVELOPE_KEY_ID = "send";
+export const MESSAGE_ENCRYPTION = [2, "message encryption"];
+export const BRC78_VERSION = Uint8Array.of(0x42, 0x42, 0x10, 0x33);
+export function signedPart(env) {
+    const { content: _c, ...rest } = env;
+    return rest;
+}
+/** hex SHA-256 of the plaintext content. */
+export const contentHash = (body) => createHash("sha256").update(body).digest("hex");
+// ---------------------------------------------------------------- RFC 8785
+/**
+ * RFC 8785 (JCS) canonical JSON of the envelope without `content` and
+ * `signature`: keys sorted by UTF-16 code units, no whitespace, strings and
+ * numbers as ECMAScript JSON.stringify writes them (which is what JCS
+ * specifies). Undefined members are omitted.
+ */
+export function canonical(env) {
+    const { content: _c, signature: _s, ...rest } = env;
+    return jcs(rest);
+}
+export function jcs(v) {
+    if (v === null || typeof v === "boolean" || typeof v === "string")
+        return JSON.stringify(v);
+    if (typeof v === "number") {
+        if (!Number.isFinite(v))
+            throw new TypeError("JCS: non-finite number");
+        return JSON.stringify(v); // ES Number::toString, -0 → "0": exactly JCS
+    }
+    if (Array.isArray(v))
+        return `[${v.map((x) => (x === undefined ? "null" : jcs(x))).join(",")}]`;
+    if (typeof v === "object") {
+        const o = v;
+        const keys = Object.keys(o).filter((k) => o[k] !== undefined).sort(); // default sort compares UTF-16 code units
+        return `{${keys.map((k) => `${JSON.stringify(k)}:${jcs(o[k])}`).join(",")}}`;
+    }
+    throw new TypeError(`JCS: cannot canonicalize ${typeof v}`);
+}
+export function brc78Encode(m) {
+    if (m.keyId.length !== 32)
+        throw new TypeError("BRC-78: key id must be 32 bytes");
+    const s = Buffer.from(m.sender, "hex"), r = Buffer.from(m.recipient, "hex");
+    if (s.length !== 33 || r.length !== 33)
+        throw new TypeError("BRC-78: identities must be 33-byte compressed keys");
+    return Buffer.concat([BRC78_VERSION, s, r, m.keyId, m.ciphertext]);
+}
+export function brc78Decode(bytes) {
+    if (bytes.length < 4 + 33 + 33 + 32 + 32)
+        throw new TypeError("BRC-78: too short");
+    const version = bytes.subarray(0, 4);
+    if (!Buffer.from(version).equals(BRC78_VERSION))
+        throw new TypeError(`BRC-78: version ${Buffer.from(version).toString("hex")}, want 42421033`);
+    return {
+        version,
+        sender: Buffer.from(bytes.subarray(4, 37)).toString("hex"),
+        recipient: Buffer.from(bytes.subarray(37, 70)).toString("hex"),
+        keyId: bytes.subarray(70, 102),
+        ciphertext: bytes.subarray(102),
+    };
+}
+// ---------------------------------------------------------------- verify
+/**
+ * The signature against sender.identityKey, with no wallet: the signing key is
+ * derived per BRC-42 (invoice "2-metanet handles envelope-1", counterparty
+ * anyone). Also checks the shape, and, when `content` is present, that the
+ * BRC-78 content names the same sender. Works on the signed part alone.
+ */
+export function verify(env) {
+    if (!isSigned(env))
+        return false;
+    if ("content" in env && env.content !== undefined) {
+        try {
+            if (typeof env.content !== "string" || brc78Decode(Buffer.from(env.content, "base64")).sender !== env.sender.identityKey)
+                return false;
+        }
+        catch {
+            return false;
+        }
+    }
+    return verifyAnyone(env.sender.identityKey, ENVELOPE_PROTOCOL, ENVELOPE_KEY_ID, Buffer.from(canonical(env), "utf8"), Buffer.from(env.signature, "hex"));
+}
+const KEY = /^0[23][0-9a-f]{64}$/;
+export function isSigned(x) {
+    const e = x;
+    return !!e && typeof e === "object" && e.metanetHandles === "1.0"
+        && !!e.recipient && typeof e.recipient.handle === "string" && typeof e.recipient.domain === "string"
+        && (e.recipient.tag === undefined || typeof e.recipient.tag === "string")
+        && !!e.sender && typeof e.sender.identityKey === "string" && KEY.test(e.sender.identityKey)
+        && typeof e.created === "string" && typeof e.contentHash === "string" && /^[0-9a-f]{64}$/.test(e.contentHash)
+        && typeof e.signature === "string" && /^[0-9a-f]+$/i.test(e.signature);
+}
+export function isEnvelope(x) {
+    return isSigned(x) && typeof x.content === "string";
+}

package/dist/runtime/heads.d.ts

@@ -0,0 +1,25 @@
+import type { CID } from "multiformats/cid";
+import { type Store } from "./store.ts";
+import type { Ms } from "./types.ts";
+export type HeadOrigin = {
+    kind: "head";
+    name: string;
+};
+export type HeadUpdate = {
+    origin: CID;
+    prev: CID;
+    seq: number;
+    tree: CID;
+    /** The app the head's name is under (#77): `<app>/…` → `<app>`; a bare name is its own (heads.zig ownerOf). */
+    owner: string;
+    /** Null: moved by the genesis (a system tree, #4) or a kernel operation (#77), not a thread. */
+    thread?: CID | null;
+    input: CID;
+    at: Ms;
+};
+export declare const MAIN = "main";
+export declare const isHeadName: (x: unknown) => x is string;
+/** The head's chain origin: the same CID in every store. */
+export declare function headOrigin(name: string): CID;
+/** The tree a head names now, or undefined if it has never moved. */
+export declare function headTree(store: Store, name: string): Promise<CID | undefined>;