@dcasegr/skein 0.0.0-stage → 0.1.2

package/dist/runtime/store.d.ts

@@ -0,0 +1,141 @@
+import type { CID } from "multiformats/cid";
+import type { Block, Ref, ThreadState, Ms } from "./types.ts";
+import type { Message } from "./records.ts";
+import { type Stamp } from "./syscalls.ts";
+export declare class NotFound extends Error {
+    readonly cid: string;
+    constructor(cid: string);
+}
+/** putMessage refused the record. The store is unchanged. */
+export declare class Rejected extends Error {
+    readonly reason: "bad-signature" | "duplicate-seq" | "duplicate-envelope" | "duplicate-outcome" | "out-of-order";
+    constructor(reason: Rejected["reason"], message: string);
+}
+export interface Blocks {
+    put(value: Block): Promise<CID>;
+    get<T extends Block = Block>(cid: CID): Promise<T>;
+    has(cid: CID): Promise<boolean>;
+    /** The stored dag-cbor bytes, exactly as hashed. Throws NotFound. */
+    bytes(cid: CID): Promise<Uint8Array>;
+    /** Store bytes under a CID minted elsewhere (git-raw, raw). The caller vouches the CID matches. */
+    putBlock(cid: CID, bytes: Uint8Array): Promise<void>;
+}
+export interface Chains {
+    /** Write an origin block and register its chain (tip = origin, seq 0). */
+    open(origin: Block): Promise<CID>;
+    /**
+     * Write an update {...body, origin, prev: tip, seq: n+1}; move the tip. Serialised per origin.
+     * `body.at` is required: the store has no clock (the runtime passes log time).
+     */
+    append(origin: CID, body: Record<string, unknown>): Promise<CID>;
+    /** Latest update, or the origin itself if there are none. */
+    tip(origin: CID): Promise<CID>;
+    /** origin → tip, in seq order. */
+    history(origin: CID): AsyncIterable<CID>;
+    /** Given any block in a chain, its origin (identity). */
+    originOf(cid: CID): Promise<CID>;
+}
+export interface Filter {
+    kind?: "thread" | "node" | "head" | "message";
+    thread?: CID;
+    program?: CID;
+    from?: string;
+    to?: string;
+    state?: ThreadState[];
+    parentless?: boolean;
+    since?: Ms;
+    before?: Ms;
+    limit?: number;
+    orderBy?: "at" | "tipAt";
+}
+export interface Edges {
+    refsFrom(cid: CID): Promise<Ref[]>;
+    refsTo(cid: CID): Promise<Array<Ref & {
+        from: CID;
+    }>>;
+    /** Structural narrowing over origins. Never text search. Newest first (by `orderBy`). */
+    query(filter: Filter): AsyncIterable<CID>;
+    /** Drop and rebuild the index from the blocks. */
+    rebuild(): Promise<void>;
+}
+export interface Handle {
+    [k: string]: unknown;
+}
+export interface Live {
+    handles: {
+        set(thread: CID, handle: Handle): Promise<void>;
+        get(thread: CID): Promise<Handle | undefined>;
+        clear(thread: CID): Promise<void>;
+    };
+    /** Thread origins whose tip state is not finished — the scheduler's worklist. */
+    resting(filter?: Pick<Filter, "state" | "limit">): AsyncIterable<CID>;
+    /** Threads whose `until` has passed (time trigger). */
+    due(now: Ms): AsyncIterable<CID>;
+    /** Threads waiting on `thread` (event trigger: it came to rest, wake these). */
+    waitersOn(thread: CID): AsyncIterable<CID>;
+    /** Thread origins whose tip has `waitingFrom === identity` (a message from it should wake them). */
+    waitingFrom(identity: string): AsyncIterable<CID>;
+    /** Thread origins whose tip `awaits` includes this emitted envelope: a reply naming it (`replyTo`) is theirs. */
+    awaiting(envelope: CID): AsyncIterable<CID>;
+    /** The scheduler's position in the log: entries with n < cursor have been processed. Not derived. */
+    cursor: {
+        get(): Promise<number>;
+        set(n: number): Promise<void>;
+    };
+}
+export type LogEntry = {
+    kind: "log";
+    prev: CID | null;
+    n: number;
+    time: Stamp;
+    /** Exactly one of: the genesis record (n = 0) … */
+    genesis?: CID;
+    /** … an admitted envelope's signed part (its JSON object without `content`, as dag-cbor), the BRC-33 box it arrived in, and its plaintext body … */
+    envelope?: CID;
+    box?: string;
+    body?: CID;
+    /** … a wake: the thread whose `until` this entry reaches … */
+    wake?: CID;
+    /** … or a delivery outcome: what became of an emit (docs/MESSAGES.md, "Outcomes"). At most one per emit. */
+    outcome?: Outcome;
+    /** DER, by the instance identity over the entry's dag-cbor without `sig` (log.ts). */
+    sig: Uint8Array;
+};
+/** What the delivery provider reports of an emit: sent, or refused for good (`reason`). */
+export type Outcome = {
+    emit: CID;
+    status: "delivered" | "failed";
+    reason?: string;
+};
+export interface Log {
+    /**
+     * Append a signed entry. It must extend the tip (prev = tip, n = tip.n + 1,
+     * time not before tip's) or it is Rejected "out-of-order"; an envelope
+     * already in the log is Rejected "duplicate-envelope", a second outcome for
+     * one emit "duplicate-outcome". The store does not check the signature
+     * (log.ts does).
+     */
+    append(entry: LogEntry): Promise<CID>;
+    /** The latest entry (the state hash), or undefined for an empty log. */
+    tip(): Promise<CID | undefined>;
+    /** Entries with n >= from, in order. */
+    entries(from?: number): AsyncIterable<{
+        cid: CID;
+        entry: LogEntry;
+    }>;
+    /** The entry that admitted an envelope record, if any. */
+    byEnvelope(envelope: CID): Promise<CID | undefined>;
+    /** The outcome entry for an emit record, if any. */
+    outcomeOf(emit: CID): Promise<CID | undefined>;
+}
+export interface Store extends Blocks {
+    /** Verify and store a signed message; index it by (from, seq). Rejects a bad signature or a second message at one (from, seq). */
+    putMessage(m: Message): Promise<CID>;
+    chains: Chains;
+    log: Log;
+    edges: Edges;
+    live: Live;
+    close(): Promise<void>;
+}
+/** The checks every Log.append makes, given the current tip entry. Throws Rejected. */
+export declare function checkExtends(entry: LogEntry, tipCid: CID | undefined, tip: LogEntry | undefined): void;

package/dist/runtime/store.js

@@ -0,0 +1,24 @@
+// The store interface. Five layers: blocks, chains, the input log, edges, live.
+// Everything that reads a store here (the explorer, skein-dev, skein-host)
+// calls only this. Two implementations over one SQLite file (node:sqlite):
+// the kernel's format through its index (index-store.ts), and the tables of
+// sqlite.ts (a store of blocks the tests and tools write, and files from
+// before the index of #30).
+import { stampNs } from "./syscalls.js";
+export class NotFound extends Error {
+    cid;
+    constructor(cid) { super(`not found: ${cid}`); this.cid = cid; }
+}
+/** putMessage refused the record. The store is unchanged. */
+export class Rejected extends Error {
+    reason;
+    constructor(reason, message) { super(message); this.reason = reason; }
+}
+/** The checks every Log.append makes, given the current tip entry. Throws Rejected. */
+export function checkExtends(entry, tipCid, tip) {
+    const okPrev = tipCid ? entry.prev !== null && entry.prev.equals(tipCid) : entry.prev === null;
+    const okN = entry.n === (tip ? tip.n + 1 : 0);
+    const okTime = !tip || stampNs(entry.time) >= stampNs(tip.time);
+    if (!okPrev || !okN || !okTime)
+        throw new Rejected("out-of-order", `log: entry #${entry.n} does not extend the tip${okTime ? "" : " (stamped before it)"}`);
+}

package/dist/runtime/syscalls.d.ts

@@ -0,0 +1,9 @@
+import type { CID } from "multiformats/cid";
+/** A log-entry stamp: whole seconds and nanoseconds since the Unix epoch (both safe integers, nsec < 1e9). */
+export type Stamp = [sec: number, nsec: number];
+export declare const stampNs: (s: Stamp) => bigint;
+export declare const msStamp: (ms: number) => Stamp;
+/** The later of two stamps. */
+export declare const maxStamp: (a: Stamp, b: Stamp) => Stamp;
+/** The random stream for (entry, thread): SHA-256(key ‖ counter as u64 BE), block after block. */
+export declare function entropy(entry: CID, thread: CID): (len: number) => Uint8Array;

package/dist/runtime/syscalls.js

@@ -0,0 +1,41 @@
+// Time and randomness as the log defines them (docs/ARCH.md, "Time and
+// randomness"; the kernel's syscalls.zig). Both are pure functions of records.
+//
+// Time. Every log entry carries its admission stamp, `time: [sec, nsec]`;
+// inside the machine every clock reads from the stamp of the entry a step is
+// driven by, never from a wall clock.
+//
+// Random. random_get draws from a SHA-256 counter stream keyed by
+// (current log entry CID, thread origin CID): distinct per entry and per
+// sibling thread, fixed on replay, and with no seed anywhere. Never use it for
+// secrets — it is a pure function of public records. The kernel's stream is
+// checked against this one (kernel-zig/test/fixtures.json).
+import { createHash } from "node:crypto";
+export const stampNs = (s) => BigInt(s[0]) * 1000000000n + BigInt(s[1]);
+export const msStamp = (ms) => [Math.floor(ms / 1000), (ms % 1000) * 1_000_000];
+/** The later of two stamps. */
+export const maxStamp = (a, b) => (stampNs(a) >= stampNs(b) ? a : b);
+/** The random stream for (entry, thread): SHA-256(key ‖ counter as u64 BE), block after block. */
+export function entropy(entry, thread) {
+    const key = createHash("sha256").update(entry.bytes).update(thread.bytes).digest();
+    let counter = 0n;
+    let buf = new Uint8Array(0);
+    let off = 0;
+    return (len) => {
+        const out = new Uint8Array(len);
+        let i = 0;
+        while (i < len) {
+            if (off === buf.length) {
+                const c = new Uint8Array(8);
+                new DataView(c.buffer).setBigUint64(0, counter++);
+                buf = new Uint8Array(createHash("sha256").update(key).update(c).digest());
+                off = 0;
+            }
+            const take = Math.min(len - i, buf.length - off);
+            out.set(buf.subarray(off, off + take), i);
+            i += take;
+            off += take;
+        }
+        return out;
+    };
+}

package/dist/runtime/tree.d.ts

@@ -0,0 +1,60 @@
+import { CID } from "multiformats/cid";
+import type { Blocks } from "./store.ts";
+export declare const GIT_RAW = 120;
+/** Modes we write. */
+export type Mode = "100644" | "100755" | "120000" | "40000";
+/** Modes we read: 160000 (gitlink/submodule) only arrives from real repos. */
+export type EntryMode = Mode | "160000";
+export interface Entry {
+    mode: EntryMode;
+    name: string;
+    cid: CID;
+}
+export interface Leaf {
+    mode: EntryMode;
+    cid: CID;
+}
+/** All this module needs from a store. */
+export type TreeBlocks = Pick<Blocks, "bytes" | "has" | "putBlock">;
+export declare function gitCid(sha1hex: string): CID;
+export declare function gitSha(cid: CID): string;
+export declare function sha1Cid(digest: Uint8Array): CID;
+export declare function header(type: "blob" | "tree", len: number): Buffer;
+export declare function blobCid(bytes: Uint8Array): CID;
+export declare function hashBlob(bytes: Uint8Array): {
+    cid: CID;
+    object: Uint8Array;
+};
+export declare function hashTree(entries: Entry[]): {
+    cid: CID;
+    object: Uint8Array;
+};
+/** The empty tree: what a run with no tree starts from (the kernel's tree.zig hashTree(&.{})). */
+export declare const EMPTY_TREE: CID<unknown, number, number, import("multiformats/cid").Version>;
+export declare function parseTree(object: Uint8Array, cid?: CID): Entry[];
+export declare function readTree(blocks: TreeBlocks, cid: CID): Promise<Entry[]>;
+export declare function readBlob(blocks: TreeBlocks, cid: CID): Promise<Uint8Array>;
+/** The entry at `path` ("" is the root tree itself), or undefined. */
+export declare function lookup(blocks: TreeBlocks, tree: CID, path: string): Promise<Leaf | undefined>;
+/** File contents (a symlink's contents are its target). */
+export declare function readFile(blocks: TreeBlocks, tree: CID, path: string): Promise<Uint8Array>;
+/** Every entry under `path`, depth first in tree order. Directories only with `dirs`. */
+export declare function walk(blocks: TreeBlocks, tree: CID, path?: string, opts?: {
+    dirs?: boolean;
+}): AsyncGenerator<{
+    path: string;
+    mode: EntryMode;
+    cid: CID;
+}>;
+export interface Change {
+    type: "added" | "removed" | "modified" | "renamed";
+    path: string;
+    /** renamed: the old path. */
+    from?: string;
+    a?: Leaf;
+    b?: Leaf;
+}
+/** File-level changes a → b, sorted by path. Identical subtrees are skipped unread. */
+export declare function diff(blocks: TreeBlocks, a: CID, b: CID, opts?: {
+    renames?: boolean;
+}): Promise<Change[]>;

package/dist/runtime/tree.js

@@ -0,0 +1,196 @@
+// The filesystem as records. Files and directories are git objects byte for
+// byte ("blob <len>\0…", "tree <len>\0…"), addressed CIDv1(git-raw, sha1 of
+// the whole object), so the digest *is* git's object id: a real repo, gib and
+// this store share one id space with no translation layer.
+//
+// Pure: hashing and reading only. Scanning a directory and checking a tree out
+// onto a disk are outside the machine (src/dev/scan.ts).
+import { createHash } from "node:crypto";
+import { CID } from "multiformats/cid";
+import * as Digest from "multiformats/hashes/digest";
+export const GIT_RAW = 0x78;
+const SHA1 = 0x11;
+const MODES = new Set(["100644", "100755", "120000", "40000", "160000"]);
+// ---------------------------------------------------------------- ids
+export function gitCid(sha1hex) {
+    if (!/^[0-9a-f]{40}$/.test(sha1hex))
+        throw new Error(`not a sha1: ${sha1hex}`);
+    return CID.createV1(GIT_RAW, Digest.create(SHA1, Buffer.from(sha1hex, "hex")));
+}
+export function gitSha(cid) {
+    if (cid.code !== GIT_RAW || cid.multihash.code !== SHA1)
+        throw new Error(`not a git object cid: ${cid}`);
+    return Buffer.from(cid.multihash.digest).toString("hex");
+}
+export function sha1Cid(digest) {
+    return CID.createV1(GIT_RAW, Digest.create(SHA1, digest));
+}
+export function header(type, len) {
+    return Buffer.from(`${type} ${len}\0`, "latin1");
+}
+// ---------------------------------------------------------------- hashing
+export function blobCid(bytes) {
+    return sha1Cid(createHash("sha1").update(header("blob", bytes.length)).update(bytes).digest());
+}
+export function hashBlob(bytes) {
+    const object = Buffer.concat([header("blob", bytes.length), bytes]);
+    return { cid: sha1Cid(createHash("sha1").update(object).digest()), object };
+}
+export function hashTree(entries) {
+    const seen = new Set();
+    const keyed = entries.map((e) => {
+        if (!MODES.has(e.mode))
+            throw new Error(`bad mode ${e.mode} for ${e.name}`);
+        if (!e.name || e.name.includes("/") || e.name.includes("\0"))
+            throw new Error(`bad entry name: ${JSON.stringify(e.name)}`);
+        if (seen.has(e.name))
+            throw new Error(`duplicate entry: ${e.name}`);
+        seen.add(e.name);
+        gitSha(e.cid); // throws unless it is a git object id
+        // git orders as if a directory's name ended in "/" (so "foo.txt" < "foo" dir < "foo0").
+        return { e, key: Buffer.from(e.mode === "40000" ? `${e.name}/` : e.name, "utf8") };
+    });
+    keyed.sort((a, b) => Buffer.compare(a.key, b.key));
+    const parts = [];
+    for (const { e } of keyed)
+        parts.push(Buffer.from(`${e.mode} ${e.name}\0`, "utf8"), e.cid.multihash.digest);
+    const body = Buffer.concat(parts);
+    const object = Buffer.concat([header("tree", body.length), body]);
+    return { cid: sha1Cid(createHash("sha1").update(object).digest()), object };
+}
+/** The empty tree: what a run with no tree starts from (the kernel's tree.zig hashTree(&.{})). */
+export const EMPTY_TREE = hashTree([]).cid;
+// ---------------------------------------------------------------- reading
+function body(object, type, cid) {
+    const buf = Buffer.from(object.buffer, object.byteOffset, object.byteLength);
+    const nul = buf.indexOf(0);
+    const head = nul < 0 ? "" : buf.toString("latin1", 0, nul);
+    if (head !== `${type} ${buf.length - nul - 1}`)
+        throw new Error(`not a git ${type}: ${cid}`);
+    return buf.subarray(nul + 1);
+}
+export function parseTree(object, cid) {
+    const b = body(object, "tree", cid);
+    const out = [];
+    let i = 0;
+    while (i < b.length) {
+        const sp = b.indexOf(0x20, i);
+        const z = sp < 0 ? -1 : b.indexOf(0, sp);
+        if (z < 0 || z + 21 > b.length)
+            throw new Error(`truncated tree: ${cid}`);
+        const mode = b.toString("latin1", i, sp);
+        if (!MODES.has(mode))
+            throw new Error(`unsupported mode ${mode} in ${cid}`);
+        out.push({ mode: mode, name: b.toString("utf8", sp + 1, z), cid: sha1Cid(b.subarray(z + 1, z + 21)) });
+        i = z + 21;
+    }
+    return out;
+}
+export async function readTree(blocks, cid) {
+    gitSha(cid);
+    return parseTree(await blocks.bytes(cid), cid);
+}
+export async function readBlob(blocks, cid) {
+    gitSha(cid);
+    return body(await blocks.bytes(cid), "blob", cid);
+}
+/** The entry at `path` ("" is the root tree itself), or undefined. */
+export async function lookup(blocks, tree, path) {
+    let at = { mode: "40000", cid: tree };
+    for (const seg of path.split("/").filter(Boolean)) {
+        if (at.mode !== "40000")
+            return undefined;
+        const e = (await readTree(blocks, at.cid)).find((x) => x.name === seg);
+        if (!e)
+            return undefined;
+        at = e;
+    }
+    return at;
+}
+/** File contents (a symlink's contents are its target). */
+export async function readFile(blocks, tree, path) {
+    const e = await lookup(blocks, tree, path);
+    if (!e)
+        throw new Error(`no such path: ${path}`);
+    if (e.mode === "40000" || e.mode === "160000")
+        throw new Error(`not a file: ${path}`);
+    return readBlob(blocks, e.cid);
+}
+/** Every entry under `path`, depth first in tree order. Directories only with `dirs`. */
+export async function* walk(blocks, tree, path = "", opts = {}) {
+    const start = await lookup(blocks, tree, path);
+    if (!start || start.mode !== "40000")
+        throw new Error(`not a directory: ${path}`);
+    const prefix = path.split("/").filter(Boolean).join("/");
+    async function* rec(cid, pre) {
+        for (const e of await readTree(blocks, cid)) {
+            const p = pre ? `${pre}/${e.name}` : e.name;
+            if (e.mode === "40000") {
+                if (opts.dirs)
+                    yield { path: p, mode: e.mode, cid: e.cid };
+                yield* rec(e.cid, p);
+            }
+            else
+                yield { path: p, mode: e.mode, cid: e.cid };
+        }
+    }
+    yield* rec(start.cid, prefix);
+}
+/** File-level changes a → b, sorted by path. Identical subtrees are skipped unread. */
+export async function diff(blocks, a, b, opts = {}) {
+    const out = [];
+    const all = async (cid, pre, type) => {
+        for await (const e of walk(blocks, cid))
+            out.push({ type, path: `${pre}/${e.path}`, [type === "added" ? "b" : "a"]: { mode: e.mode, cid: e.cid } });
+    };
+    const rec = async (x, y, pre) => {
+        const ex = new Map((await readTree(blocks, x)).map((e) => [e.name, e]));
+        const ey = new Map((await readTree(blocks, y)).map((e) => [e.name, e]));
+        for (const name of new Set([...ex.keys(), ...ey.keys()])) {
+            const l = ex.get(name), r = ey.get(name);
+            if (l && r && l.mode === r.mode && l.cid.equals(r.cid))
+                continue;
+            const p = pre ? `${pre}/${name}` : name;
+            const lDir = l?.mode === "40000", rDir = r?.mode === "40000";
+            if (lDir && rDir) {
+                await rec(l.cid, r.cid, p);
+                continue;
+            }
+            if (lDir)
+                await all(l.cid, p, "removed");
+            if (rDir)
+                await all(r.cid, p, "added");
+            const lf = l && !lDir ? { mode: l.mode, cid: l.cid } : undefined;
+            const rf = r && !rDir ? { mode: r.mode, cid: r.cid } : undefined;
+            if (lf && rf)
+                out.push({ type: "modified", path: p, a: lf, b: rf });
+            else if (lf)
+                out.push({ type: "removed", path: p, a: lf });
+            else if (rf)
+                out.push({ type: "added", path: p, b: rf });
+        }
+    };
+    await rec(a, b, "");
+    let changes = out;
+    if (opts.renames ?? true) {
+        // Exact renames only: the same blob gone from one path and new at another.
+        const gone = new Map();
+        for (const c of out) {
+            if (c.type !== "removed")
+                continue;
+            const k = c.a.cid.toString();
+            gone.set(k, [...(gone.get(k) ?? []), c]);
+        }
+        const paired = new Set();
+        changes = out.flatMap((c) => {
+            if (c.type !== "added")
+                return [c];
+            const from = gone.get(c.b.cid.toString())?.shift();
+            if (!from)
+                return [c];
+            paired.add(from);
+            return [{ type: "renamed", path: c.path, from: from.path, a: from.a, b: c.b }];
+        }).filter((c) => !paired.has(c));
+    }
+    return changes.sort((x, y) => (x.path < y.path ? -1 : x.path > y.path ? 1 : 0));
+}

package/dist/runtime/types.d.ts

@@ -0,0 +1,100 @@
+import type { CID } from "multiformats/cid";
+export type Ms = number;
+export type Rel = "depends-on" | "launched" | "produced" | "about" | "replies-to" | (string & {});
+export interface Ref {
+    to: CID | string;
+    rel: Rel;
+    locator?: string;
+}
+export type ThreadState = "running" | "waiting" | "finished" | "errored" | "out-of-context" | "dropped";
+export interface ThreadOrigin {
+    kind: "thread";
+    program: CID;
+    args: unknown;
+    launchedBy?: CID;
+    input?: CID;
+    at: Ms;
+    nonce?: string;
+}
+export interface ThreadUpdate {
+    origin: CID;
+    prev: CID;
+    seq: number;
+    at: Ms;
+    state: ThreadState;
+    waitingOn?: CID[];
+    waitingFrom?: string;
+    awaits?: CID[];
+    until?: Ms;
+    resolution?: CID;
+    error?: {
+        kind: "cant-do" | "blew-up";
+        message: string;
+    };
+    note?: string;
+    input?: CID;
+    refs?: Ref[];
+    result?: unknown;
+}
+export type Emission = {
+    type: "thinking";
+    text: string;
+} | {
+    type: "text";
+    text: string;
+} | {
+    type: "say";
+    text: string;
+    call?: string;
+} | {
+    type: "page";
+    markdown: string;
+    call?: string;
+} | {
+    type: "launched";
+    thread: CID;
+    label?: string;
+    call?: string;
+} | {
+    type: "tool_result";
+    thread: CID;
+    ok: boolean;
+    content: string;
+    call?: string;
+} | {
+    type: "conclusion";
+    text: string;
+    exitCode?: number;
+} | {
+    type: string;
+    [k: string]: unknown;
+};
+export interface Rest {
+    state: ThreadState;
+    waitingOn?: CID[];
+}
+export interface NodeOrigin {
+    kind: "node";
+    thread: CID;
+    prev: CID[];
+    request: unknown;
+    refs: Ref[];
+    at: Ms;
+    nonce?: string;
+    input?: CID;
+}
+export interface NodeUpdate {
+    origin: CID;
+    prev: CID;
+    seq: number;
+    at: Ms;
+    emit?: Emission;
+    rest?: Rest;
+    input?: CID;
+}
+export type Origin = ThreadOrigin | NodeOrigin;
+export type Update = ThreadUpdate | NodeUpdate;
+export type Block = Origin | Update | {
+    kind: string;
+    [k: string]: unknown;
+};

package/dist/runtime/types.js

@@ -0,0 +1,7 @@
+// Block shapes. Every value here is encoded as dag-cbor and identified by its
+// CIDv1 (codec dag-cbor 0x71, multihash sha2-256 0x12). See docs/MODEL.md.
+//
+// CIDs are carried as multiformats `CID` instances inside blocks (dag-cbor
+// tag 42) and as base32 strings (`bafy…`) everywhere a string is needed:
+// the CLI, the index tables, URLs (`skein://bafy…`).
+export {};