@inversealtruism/cairn-sdk 0.1.0

package/LICENSE

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

package/README.md

@@ -0,0 +1,108 @@
+# @inversealtruism/cairn-sdk
+
+The **Compute Substrate dApp kit** — one cohesive toolkit for building apps on CSD. It composes everything in the Cairn ecosystem behind a single `Cairn` object:
+
+| | |
+|---|---|
+| `cairn.wallet` | Connect the **Cairn Wallet**, sign things (clear-signed approvals). The key never leaves the extension. |
+| `cairn.chain` | Node RPC + transaction builders + a verifying **light client** (re-exports the `csd-*` primitives). |
+| `cairn.board` | The signal **board** + work graph. Reads are public; writes are wallet-signed. |
+| `cairn.index` | The L2 **explorer/indexer**: REST + merkle proofs + live SSE/WS feeds. |
+| `cairn.content` | **Self-certifying content** — publish via the board, fetch with client-side verification. |
+| `cairn.registry` | L3 **peer / gateway / identity** resolution. |
+
+```bash
+npm i @inversealtruism/cairn-sdk
+```
+
+## Quick start
+
+```ts
+import { Cairn } from "@inversealtruism/cairn-sdk";
+
+const cairn = new Cairn({ network: "mainnet" });   // defaults to cairn-substrate.com
+
+// reads need no wallet
+const top = await cairn.board.top({ domain: "csd:apps" });
+const tip = await cairn.chain.tip();
+
+// connect the user's wallet (browser) — prompts once, then "connected"
+await cairn.connect();
+
+// publish a board item, signed by the user's wallet (clear-signed approval)
+const { txid } = await cairn.board.propose({
+  domain: "csd:apps",
+  title: "My dApp",
+  body: "Built with the Cairn SDK",
+});
+
+// watch it land, live
+cairn.index.streamAll({ onProposal: (e) => console.log("new proposal", e) });
+```
+
+## How wallet connection works (and why it's safe)
+
+The SDK follows the exact model MetaMask uses — there is **no allowlist you maintain**:
+
+- **`connect()` / `getAddress()`** grant *address visibility*. The first time a site connects, the user approves once; after that the wallet answers silently (the site shows up under **Settings → Connected sites**, revocable anytime). This is the only "silent" call.
+- **Every signing / fund-moving call** — `send`, `propose`, `attest`, `signIn`, `sealClaim`, `revealClaim` — **always** opens the wallet's clear-signing approval window, **every time**, no matter what. Being "connected" never pre-approves a signature. A connected site cannot move a satoshi without an explicit, fully-disclosed approval click.
+
+```ts
+import { connect, UserRejectedError, NotInstalledError } from "@inversealtruism/cairn-sdk";
+
+try {
+  const { wallet, address } = await connect();
+  await wallet.send({ to: "0x…", amount: 100_000_000 }); // 1 CSD — still prompts
+} catch (e) {
+  if (e instanceof NotInstalledError) { /* tell the user to install the wallet */ }
+  if (e instanceof UserRejectedError) { /* they declined */ }
+}
+```
+
+## API by namespace
+
+**`cairn.board`** — `top()/board({domain,window})`, `item(id)`, `domains()`, `quests()/quest(id)`, `profile(addr)`, `leaderboard()`, `network()/networkSeries()/miner(addr)`, `activity()`, `wall()`; writes `propose({domain,title,body,links?,fee?})`, `support(id,{score?,confidence?,fee?})`.
+
+**`cairn.index`** — `tipHeight()`, `block()/blockTxids()`, `tx()/txStatus()/txMerkleProof()`, `address()/addressTxs()/addressUtxo()`, `proposal()/attestations()`, `reputation()`, `registryPeers()/registryGateways()/identity()`, **`verifyInclusion(txid)`** (trust-minimized), `streamAll()/streamBlocks()/streamDomain()` (SSE), `subscribe()` (WS).
+
+**`cairn.content`** — `prepare(obj)`/`put(obj)` → `{ payloadHash, canonical, bytes }`; `get(hash)` / `getBytes(hash)` (fetch **and verify** `sha256(bytes) === hash`, throws `ContentVerificationError` on tamper); `hash(obj)`.
+
+**`cairn.chain`** — `tip()`, `utxos(addr)`, `submit(nodeJsonTx)`, `.client` (full `CsdClient`), `.light()` (verifying light client). The package also re-exports the primitives under the `/chain` subpath: `buildSend/buildPropose/buildAttest`, `signTx`, `keygen`, `payloadHash`, `verifyMerkleProof`, `LightClient`, etc.
+
+**`cairn.registry`** — `gateways()`, `peers()`, `resolveName(handle)`, `reverseName(addr)`, `.fromRecords` (deterministic local resolvers).
+
+Subpath imports are available for tree-shaking: `@inversealtruism/cairn-sdk/{connect,board,indexer,content,registry,chain}`.
+
+## Examples
+
+- **`examples/read-only.mjs`** — runs today against live mainnet, no wallet, no build: `npm run test:live`. Demonstrates chain/board/indexer/registry reads + verified merkle inclusion + verified content fetch.
+- **`examples/hello-csd/`** — a no-framework browser dApp (connect → read board → publish → live feed). Build the bundle with `npm run build:example`, then serve the folder from **localhost** (the wallet injects there) with the Cairn Wallet installed.
+
+## Trust model & honest limits
+
+- **Content is always verified client-side.** `cairn.content.get()` rejects bytes that don't hash to the requested `payloadHash` — an untrusted gateway can't serve tampered content.
+- **Merkle inclusion is trust-minimized.** `verifyInclusion()` folds the proof and cross-checks the root against the on-chain header merkle → `trustLevel: "verified-inclusion"`. Without that cross-check it reports `"proof-consistent"` (indexer trusted).
+- **Balances are RPC-trusted.** Headers don't commit to the UTXO set; balance reads trust the node/proxy (same as every light client).
+- **Indexer/swarm run behind the cairn proxy.** By default `cairn.index` and content resolution use the cairn server's hardened, read-only, rate-limited `/explorer/api` reverse proxy (no separate public indexer needed). **SSE works through it; `subscribe()` (WebSocket) needs a direct indexer endpoint** — set `baseUrls.indexer` to a private/localhost indexer for WS.
+- **Today the wallet injects only on `cairn-substrate.com` + localhost.** Connecting from an arbitrary third-party origin requires the wallet's "connect anywhere" release (broadened injection), which ships after the per-origin consent layer is proven.
+
+## Configuration
+
+```ts
+new Cairn({
+  network: "mainnet",
+  baseUrls: {
+    cairn:   "https://cairn-substrate.com",        // board + /api/rpc proxy + /content origin
+    rpc:     "https://cairn-substrate.com/api/rpc", // node RPC (proxy)
+    indexer: "https://cairn-substrate.com/explorer/api",
+    swarm:   undefined,                             // optional direct swarm gateway
+  },
+  fetch,            // custom fetch (Node <18, tests)
+  timeoutMs: 15000,
+  WebSocketImpl,    // for index.subscribe() in environments without global WebSocket
+});
+```
+
+## License
+
+MIT

package/dist/board.cjs

@@ -0,0 +1,193 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/board.ts
+var board_exports = {};
+__export(board_exports, {
+  BoardClient: () => BoardClient
+});
+module.exports = __toCommonJS(board_exports);
+var import_csd_codec = require("@inversealtruism/csd-codec");
+var import_csd_codec2 = require("@inversealtruism/csd-codec");
+
+// src/errors.ts
+var CairnError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = new.target.name;
+  }
+};
+
+// src/board.ts
+var BoardClient = class {
+  http;
+  wallet;
+  constructor(http, wallet) {
+    this.http = http;
+    this.wallet = wallet;
+  }
+  requireWallet() {
+    if (!this.wallet) {
+      throw new CairnError("This action needs a connected wallet. Construct Cairn with a wallet, or call cairn.connect() first.");
+    }
+    return this.wallet;
+  }
+  // ---- reads (public) ----------------------------------------------------
+  /** Ranked board for a domain + time window. */
+  board(opts = {}) {
+    return this.http.getJson("/api/board", { domain: opts.domain ?? "all", window: opts.window ?? "all" });
+  }
+  /** Alias for `board()` — the top items. */
+  top(opts = {}) {
+    return this.board(opts);
+  }
+  /** A single item with its supports + pledges + integrity flag. */
+  item(id) {
+    return this.http.getJson(`/api/item/${encodeURIComponent(id)}`);
+  }
+  /** Known + discovered domains. */
+  domains() {
+    return this.http.getJson("/api/domains");
+  }
+  /** All quests (work-graph items). */
+  quests() {
+    return this.http.getJson("/api/quests");
+  }
+  /** A single quest with claims/submissions/payouts. */
+  quest(id) {
+    return this.http.getJson(`/api/quest/${encodeURIComponent(id)}`);
+  }
+  /** An address's on-chain-derived profile + identity + reputation. */
+  profile(addr, opts = {}) {
+    return this.http.getJson(`/api/profile/${encodeURIComponent(addr)}`, opts.live ? { live: 1 } : void 0);
+  }
+  /** Reputation leaderboard (top 50). */
+  leaderboard() {
+    return this.http.getJson("/api/leaderboard");
+  }
+  /** Network dashboard snapshot. */
+  network() {
+    return this.http.getJson("/api/network");
+  }
+  /** Network time-series for charts. */
+  networkSeries(range = "24h") {
+    return this.http.getJson("/api/network/series", { range });
+  }
+  /** Recent blocks with miner/reward. */
+  networkBlocks(limit = 15) {
+    return this.http.getJson("/api/network/blocks", { limit });
+  }
+  /** Per-miner hashrate estimate. */
+  miner(addr) {
+    return this.http.getJson(`/api/miner/${encodeURIComponent(addr)}`);
+  }
+  /** Recent activity feed. */
+  activity() {
+    return this.http.getJson("/api/activity");
+  }
+  /** The gamified cairn wall. */
+  wall() {
+    return this.http.getJson("/api/wall");
+  }
+  /** Server health + chain reachability. */
+  health() {
+    return this.http.getJson("/api/health");
+  }
+  // ---- writes (wallet-signed) -------------------------------------------
+  /**
+   * Publish a board item: compute the canonical payload hash, have the WALLET
+   * build/sign/submit the Propose (clear-signed approval), then register the
+   * off-chain content. The payload hash is byte-identical to what the cairn
+   * server verifies (csd-codec.payloadHash over { v:1, domain, title, body, links }).
+   */
+  async propose(input) {
+    const wallet = this.requireWallet();
+    const content = {
+      v: 1,
+      domain: input.domain,
+      title: input.title,
+      body: input.body ?? "",
+      links: input.links ?? []
+    };
+    const ph = (0, import_csd_codec.payloadHash)(content);
+    const uri = `cairn:v1:${ph.slice(2, 14)}`;
+    const lifetime = input.lifetimeEpochs ?? 720;
+    const height = await this.tipHeight();
+    const expiresEpoch = Math.floor(height / import_csd_codec2.EPOCH_LEN) + lifetime;
+    const fee = input.fee ?? import_csd_codec2.MIN_FEE_PROPOSE;
+    const r = await wallet.propose({ domain: content.domain, payloadHash: ph, uri, expiresEpoch, fee });
+    const txid = String(r.txid ?? "");
+    if (!txid) throw new CairnError("Propose submitted but no txid was returned by the wallet.");
+    const reg = await this.tryRegister(content, txid);
+    return { txid, payloadHash: ph, content, registered: reg.ok, registerError: reg.error };
+  }
+  /**
+   * Register off-chain content for an already-submitted proposal txid. Idempotent.
+   * Returns { ok } — the cairn server verifies sha256(canonical) == on-chain payload_hash.
+   */
+  async registerContent(content, txid) {
+    try {
+      const res = await this.http.postJson("/api/content", {
+        domain: content.domain,
+        title: content.title,
+        body: content.body,
+        links: content.links,
+        txid
+      });
+      return { ok: !!res.ok, error: res.ok ? void 0 : res.error };
+    } catch (e) {
+      return { ok: false, error: e instanceof Error ? e.message : String(e) };
+    }
+  }
+  /** Support/attest a proposal (wallet-signed; always clear-signed). */
+  async support(proposalId, opts = {}) {
+    const wallet = this.requireWallet();
+    return wallet.attest({
+      proposalId,
+      score: opts.score ?? 80,
+      confidence: opts.confidence ?? 70,
+      fee: opts.fee ?? import_csd_codec2.MIN_FEE_ATTEST
+    });
+  }
+  // ---- internal ----------------------------------------------------------
+  async tipHeight() {
+    const tip = await this.http.getJson("/api/rpc/tip");
+    const h = Number(tip?.height);
+    if (!Number.isFinite(h)) throw new CairnError("Could not read chain tip height for expiry computation.");
+    return h;
+  }
+  async tryRegister(content, txid) {
+    const delays = [0, 1500, 3e3, 5e3];
+    let last = { ok: false, error: "not attempted" };
+    for (const d of delays) {
+      if (d) await sleep(d);
+      last = await this.registerContent(content, txid);
+      if (last.ok) return last;
+      if (!/not found yet|not found/i.test(last.error ?? "")) return last;
+    }
+    return last;
+  }
+};
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BoardClient
+});

package/dist/board.d.cts

@@ -0,0 +1,151 @@
+import { H as Http } from './http-D2CzfOsm.cjs';
+import { WalletConnection, TxResult } from './connect.cjs';
+
+type BoardWindow = "24h" | "7d" | "30d" | "all";
+/** A ranked board item (loose — the server returns a rich object). */
+interface RankedItem {
+    id: string;
+    title: string;
+    body: string;
+    domain: string;
+    proposer: string;
+    score: number;
+    totalWeight: number;
+    [k: string]: unknown;
+}
+interface BoardItemContent {
+    v: 1;
+    domain: string;
+    title: string;
+    body: string;
+    links: string[];
+}
+interface ProposeInput {
+    domain: string;
+    title: string;
+    body?: string;
+    links?: string[];
+    /** Fee in base units (default MIN_FEE_PROPOSE = 0.25 CSD). */
+    fee?: number;
+    /** Lifetime in epochs before expiry (default 720 ≈ 30 days, matching cairn). */
+    lifetimeEpochs?: number;
+}
+interface ProposeResult {
+    txid: string;
+    payloadHash: string;
+    content: BoardItemContent;
+    /** Whether the off-chain content was registered with the cairn origin yet. */
+    registered: boolean;
+    /** If registration is still pending, call `registerContent(content, txid)` again later. */
+    registerError?: string;
+}
+interface SupportInput {
+    /** 0–100 quality score (default 80). */
+    score?: number;
+    /** 0–100 confidence (default 70). */
+    confidence?: number;
+    /** Fee in base units (default MIN_FEE_ATTEST = 0.05 CSD). */
+    fee?: number;
+}
+declare class BoardClient {
+    private readonly http;
+    private readonly wallet?;
+    constructor(http: Http, wallet?: WalletConnection);
+    private requireWallet;
+    /** Ranked board for a domain + time window. */
+    board(opts?: {
+        domain?: string;
+        window?: BoardWindow;
+    }): Promise<{
+        window: string;
+        domain: string;
+        count: number;
+        items: RankedItem[];
+    }>;
+    /** Alias for `board()` — the top items. */
+    top(opts?: {
+        domain?: string;
+        window?: BoardWindow;
+    }): Promise<{
+        window: string;
+        domain: string;
+        count: number;
+        items: RankedItem[];
+    }>;
+    /** A single item with its supports + pledges + integrity flag. */
+    item(id: string): Promise<{
+        ok: boolean;
+        item: RankedItem;
+        supports: unknown[];
+        pledges: unknown[];
+        integrityOk: boolean;
+    }>;
+    /** Known + discovered domains. */
+    domains(): Promise<{
+        prefix: string;
+        total: number;
+        domains: unknown[];
+        discovered: unknown[];
+    }>;
+    /** All quests (work-graph items). */
+    quests(): Promise<{
+        count: number;
+        quests: unknown[];
+    }>;
+    /** A single quest with claims/submissions/payouts. */
+    quest(id: string): Promise<{
+        ok: boolean;
+        quest: unknown;
+    }>;
+    /** An address's on-chain-derived profile + identity + reputation. */
+    profile(addr: string, opts?: {
+        live?: boolean;
+    }): Promise<{
+        ok: boolean;
+        profile: unknown;
+        identity: unknown;
+        reputation: unknown;
+    }>;
+    /** Reputation leaderboard (top 50). */
+    leaderboard(): Promise<{
+        count: number;
+        leaderboard: unknown[];
+    }>;
+    /** Network dashboard snapshot. */
+    network(): Promise<unknown>;
+    /** Network time-series for charts. */
+    networkSeries(range?: "24h" | "1w" | "1m" | "all"): Promise<unknown>;
+    /** Recent blocks with miner/reward. */
+    networkBlocks(limit?: number): Promise<unknown>;
+    /** Per-miner hashrate estimate. */
+    miner(addr: string): Promise<unknown>;
+    /** Recent activity feed. */
+    activity(): Promise<{
+        activity: unknown[];
+    }>;
+    /** The gamified cairn wall. */
+    wall(): Promise<unknown>;
+    /** Server health + chain reachability. */
+    health(): Promise<unknown>;
+    /**
+     * Publish a board item: compute the canonical payload hash, have the WALLET
+     * build/sign/submit the Propose (clear-signed approval), then register the
+     * off-chain content. The payload hash is byte-identical to what the cairn
+     * server verifies (csd-codec.payloadHash over { v:1, domain, title, body, links }).
+     */
+    propose(input: ProposeInput): Promise<ProposeResult>;
+    /**
+     * Register off-chain content for an already-submitted proposal txid. Idempotent.
+     * Returns { ok } — the cairn server verifies sha256(canonical) == on-chain payload_hash.
+     */
+    registerContent(content: BoardItemContent, txid: string): Promise<{
+        ok: boolean;
+        error?: string;
+    }>;
+    /** Support/attest a proposal (wallet-signed; always clear-signed). */
+    support(proposalId: string, opts?: SupportInput): Promise<TxResult>;
+    private tipHeight;
+    private tryRegister;
+}
+
+export { BoardClient, type BoardItemContent, type BoardWindow, type ProposeInput, type ProposeResult, type RankedItem, type SupportInput };

package/dist/board.d.ts

@@ -0,0 +1,151 @@
+import { H as Http } from './http-D2CzfOsm.js';
+import { WalletConnection, TxResult } from './connect.js';
+
+type BoardWindow = "24h" | "7d" | "30d" | "all";
+/** A ranked board item (loose — the server returns a rich object). */
+interface RankedItem {
+    id: string;
+    title: string;
+    body: string;
+    domain: string;
+    proposer: string;
+    score: number;
+    totalWeight: number;
+    [k: string]: unknown;
+}
+interface BoardItemContent {
+    v: 1;
+    domain: string;
+    title: string;
+    body: string;
+    links: string[];
+}
+interface ProposeInput {
+    domain: string;
+    title: string;
+    body?: string;
+    links?: string[];
+    /** Fee in base units (default MIN_FEE_PROPOSE = 0.25 CSD). */
+    fee?: number;
+    /** Lifetime in epochs before expiry (default 720 ≈ 30 days, matching cairn). */
+    lifetimeEpochs?: number;
+}
+interface ProposeResult {
+    txid: string;
+    payloadHash: string;
+    content: BoardItemContent;
+    /** Whether the off-chain content was registered with the cairn origin yet. */
+    registered: boolean;
+    /** If registration is still pending, call `registerContent(content, txid)` again later. */
+    registerError?: string;
+}
+interface SupportInput {
+    /** 0–100 quality score (default 80). */
+    score?: number;
+    /** 0–100 confidence (default 70). */
+    confidence?: number;
+    /** Fee in base units (default MIN_FEE_ATTEST = 0.05 CSD). */
+    fee?: number;
+}
+declare class BoardClient {
+    private readonly http;
+    private readonly wallet?;
+    constructor(http: Http, wallet?: WalletConnection);
+    private requireWallet;
+    /** Ranked board for a domain + time window. */
+    board(opts?: {
+        domain?: string;
+        window?: BoardWindow;
+    }): Promise<{
+        window: string;
+        domain: string;
+        count: number;
+        items: RankedItem[];
+    }>;
+    /** Alias for `board()` — the top items. */
+    top(opts?: {
+        domain?: string;
+        window?: BoardWindow;
+    }): Promise<{
+        window: string;
+        domain: string;
+        count: number;
+        items: RankedItem[];
+    }>;
+    /** A single item with its supports + pledges + integrity flag. */
+    item(id: string): Promise<{
+        ok: boolean;
+        item: RankedItem;
+        supports: unknown[];
+        pledges: unknown[];
+        integrityOk: boolean;
+    }>;
+    /** Known + discovered domains. */
+    domains(): Promise<{
+        prefix: string;
+        total: number;
+        domains: unknown[];
+        discovered: unknown[];
+    }>;
+    /** All quests (work-graph items). */
+    quests(): Promise<{
+        count: number;
+        quests: unknown[];
+    }>;
+    /** A single quest with claims/submissions/payouts. */
+    quest(id: string): Promise<{
+        ok: boolean;
+        quest: unknown;
+    }>;
+    /** An address's on-chain-derived profile + identity + reputation. */
+    profile(addr: string, opts?: {
+        live?: boolean;
+    }): Promise<{
+        ok: boolean;
+        profile: unknown;
+        identity: unknown;
+        reputation: unknown;
+    }>;
+    /** Reputation leaderboard (top 50). */
+    leaderboard(): Promise<{
+        count: number;
+        leaderboard: unknown[];
+    }>;
+    /** Network dashboard snapshot. */
+    network(): Promise<unknown>;
+    /** Network time-series for charts. */
+    networkSeries(range?: "24h" | "1w" | "1m" | "all"): Promise<unknown>;
+    /** Recent blocks with miner/reward. */
+    networkBlocks(limit?: number): Promise<unknown>;
+    /** Per-miner hashrate estimate. */
+    miner(addr: string): Promise<unknown>;
+    /** Recent activity feed. */
+    activity(): Promise<{
+        activity: unknown[];
+    }>;
+    /** The gamified cairn wall. */
+    wall(): Promise<unknown>;
+    /** Server health + chain reachability. */
+    health(): Promise<unknown>;
+    /**
+     * Publish a board item: compute the canonical payload hash, have the WALLET
+     * build/sign/submit the Propose (clear-signed approval), then register the
+     * off-chain content. The payload hash is byte-identical to what the cairn
+     * server verifies (csd-codec.payloadHash over { v:1, domain, title, body, links }).
+     */
+    propose(input: ProposeInput): Promise<ProposeResult>;
+    /**
+     * Register off-chain content for an already-submitted proposal txid. Idempotent.
+     * Returns { ok } — the cairn server verifies sha256(canonical) == on-chain payload_hash.
+     */
+    registerContent(content: BoardItemContent, txid: string): Promise<{
+        ok: boolean;
+        error?: string;
+    }>;
+    /** Support/attest a proposal (wallet-signed; always clear-signed). */
+    support(proposalId: string, opts?: SupportInput): Promise<TxResult>;
+    private tipHeight;
+    private tryRegister;
+}
+
+export { BoardClient, type BoardItemContent, type BoardWindow, type ProposeInput, type ProposeResult, type RankedItem, type SupportInput };

package/dist/board.js

@@ -0,0 +1,7 @@
+import {
+  BoardClient
+} from "./chunk-OGP2W7DL.js";
+import "./chunk-PHMU3CG5.js";
+export {
+  BoardClient
+};