@inversealtruism/cairn-sdk 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,105 @@
+import { F as FetchLike } from './http-D2CzfOsm.cjs';
+export { H as Http, a as HttpOptions } from './http-D2CzfOsm.cjs';
+import { Chain } from './chain.cjs';
+import { BoardClient } from './board.cjs';
+export { BoardItemContent, BoardWindow, ProposeInput, ProposeResult, RankedItem, SupportInput } from './board.cjs';
+import { IndexerClient } from './indexer.cjs';
+export { InclusionResult, IndexEvent, MerkleProof, StreamHandle, StreamHandlers, TrustLevel } from './indexer.cjs';
+import { ContentClient } from './content.cjs';
+export { ContentClientOptions, PreparedContent } from './content.cjs';
+import { RegistryClient } from './registry.cjs';
+import { WalletConnection, DetectOptions } from './connect.cjs';
+export { AttestParams, CairnProvider, ConnectResult, ProposeParams, SealClaimParams, SendParams, SignInResult, TxResult, connect, detectProvider, getWallet, isInstalled } from './connect.cjs';
+import '@inversealtruism/csd-client';
+import '@inversealtruism/csd-tx';
+import '@inversealtruism/csd-codec';
+import '@inversealtruism/csd-crypto';
+import '@inversealtruism/csd-light';
+import '@inversealtruism/csd-registry';
+
+declare class CairnError extends Error {
+    constructor(message: string);
+}
+/** The Cairn Wallet extension is not installed (no `window.cairn` appeared). */
+declare class NotInstalledError extends CairnError {
+    constructor(message?: string);
+}
+/** The user rejected the request in the wallet's approval window. */
+declare class UserRejectedError extends CairnError {
+    constructor(message?: string);
+}
+/** The wallet is locked; the user must unlock it before approving. */
+declare class WalletLockedError extends CairnError {
+    constructor(message?: string);
+}
+/** The method is not exposed to dApps by the wallet boundary. */
+declare class UnsupportedMethodError extends CairnError {
+    constructor(message?: string);
+}
+/** An HTTP request to a Cairn service failed (network or non-2xx). */
+declare class HttpError extends CairnError {
+    status: number;
+    url: string;
+    body?: string;
+    constructor(status: number, url: string, body?: string);
+}
+/** Self-certification failed: received bytes do not hash to the expected payload hash. */
+declare class ContentVerificationError extends CairnError {
+    expected: string;
+    constructor(expected: string);
+}
+
+interface CairnBaseUrls {
+    /** Cairn board server (board + /api/rpc proxy + /content origin). Default https://cairn-substrate.com */
+    cairn?: string;
+    /** Node RPC base. Default `${cairn}/api/rpc` (the public proxy — no local node needed). */
+    rpc?: string;
+    /**
+     * csd-indexer base. Default `${cairn}/explorer/api` — the cairn server's existing
+     * hardened, read-only, rate-limited reverse proxy to the localhost indexer (the
+     * same one the block explorer uses). SSE works through it; WebSocket subscribe()
+     * needs a direct indexer endpoint (set this to a localhost/private indexer URL).
+     */
+    indexer?: string;
+    /**
+     * Optional direct csd-swarm gateway base. Not set by default — content is reached
+     * via the indexer proxy (which fronts the swarm) and the cairn origin, both verified.
+     * Set this only if you run a public swarm gateway.
+     */
+    swarm?: string;
+}
+interface CairnConfig {
+    /** Currently only "mainnet". Selects the default base URLs. */
+    network?: "mainnet";
+    baseUrls?: CairnBaseUrls;
+    /** Custom fetch (defaults to global fetch). */
+    fetch?: FetchLike;
+    /** Per-request HTTP timeout in ms (default 15000). */
+    timeoutMs?: number;
+    /** A pre-connected wallet (otherwise call `cairn.connect()` in the browser). */
+    wallet?: WalletConnection;
+    /** WebSocket implementation for indexer subscriptions (defaults to global). */
+    WebSocketImpl?: typeof WebSocket;
+}
+declare class Cairn {
+    readonly config: CairnConfig;
+    readonly chain: Chain;
+    readonly index: IndexerClient;
+    readonly content: ContentClient;
+    readonly registry: RegistryClient;
+    board: BoardClient;
+    wallet?: WalletConnection;
+    private readonly cairnHttp;
+    constructor(config?: CairnConfig);
+    /**
+     * Detect + connect the Cairn Wallet (browser only). Wires the wallet into
+     * `cairn.board` for signed writes. Resolves to the connected address.
+     */
+    connect(opts?: DetectOptions): Promise<string>;
+    /** Attach an already-connected wallet (e.g. one you constructed yourself). */
+    attachWallet(wallet: WalletConnection): void;
+    /** True if a wallet is attached. */
+    get connected(): boolean;
+}
+
+export { BoardClient, Cairn, type CairnBaseUrls, type CairnConfig, CairnError, Chain, ContentClient, ContentVerificationError, DetectOptions, FetchLike, HttpError, IndexerClient, NotInstalledError, RegistryClient, UnsupportedMethodError, UserRejectedError, WalletConnection, WalletLockedError };

package/dist/index.d.ts

@@ -0,0 +1,105 @@
+import { F as FetchLike } from './http-D2CzfOsm.js';
+export { H as Http, a as HttpOptions } from './http-D2CzfOsm.js';
+import { Chain } from './chain.js';
+import { BoardClient } from './board.js';
+export { BoardItemContent, BoardWindow, ProposeInput, ProposeResult, RankedItem, SupportInput } from './board.js';
+import { IndexerClient } from './indexer.js';
+export { InclusionResult, IndexEvent, MerkleProof, StreamHandle, StreamHandlers, TrustLevel } from './indexer.js';
+import { ContentClient } from './content.js';
+export { ContentClientOptions, PreparedContent } from './content.js';
+import { RegistryClient } from './registry.js';
+import { WalletConnection, DetectOptions } from './connect.js';
+export { AttestParams, CairnProvider, ConnectResult, ProposeParams, SealClaimParams, SendParams, SignInResult, TxResult, connect, detectProvider, getWallet, isInstalled } from './connect.js';
+import '@inversealtruism/csd-client';
+import '@inversealtruism/csd-tx';
+import '@inversealtruism/csd-codec';
+import '@inversealtruism/csd-crypto';
+import '@inversealtruism/csd-light';
+import '@inversealtruism/csd-registry';
+
+declare class CairnError extends Error {
+    constructor(message: string);
+}
+/** The Cairn Wallet extension is not installed (no `window.cairn` appeared). */
+declare class NotInstalledError extends CairnError {
+    constructor(message?: string);
+}
+/** The user rejected the request in the wallet's approval window. */
+declare class UserRejectedError extends CairnError {
+    constructor(message?: string);
+}
+/** The wallet is locked; the user must unlock it before approving. */
+declare class WalletLockedError extends CairnError {
+    constructor(message?: string);
+}
+/** The method is not exposed to dApps by the wallet boundary. */
+declare class UnsupportedMethodError extends CairnError {
+    constructor(message?: string);
+}
+/** An HTTP request to a Cairn service failed (network or non-2xx). */
+declare class HttpError extends CairnError {
+    status: number;
+    url: string;
+    body?: string;
+    constructor(status: number, url: string, body?: string);
+}
+/** Self-certification failed: received bytes do not hash to the expected payload hash. */
+declare class ContentVerificationError extends CairnError {
+    expected: string;
+    constructor(expected: string);
+}
+
+interface CairnBaseUrls {
+    /** Cairn board server (board + /api/rpc proxy + /content origin). Default https://cairn-substrate.com */
+    cairn?: string;
+    /** Node RPC base. Default `${cairn}/api/rpc` (the public proxy — no local node needed). */
+    rpc?: string;
+    /**
+     * csd-indexer base. Default `${cairn}/explorer/api` — the cairn server's existing
+     * hardened, read-only, rate-limited reverse proxy to the localhost indexer (the
+     * same one the block explorer uses). SSE works through it; WebSocket subscribe()
+     * needs a direct indexer endpoint (set this to a localhost/private indexer URL).
+     */
+    indexer?: string;
+    /**
+     * Optional direct csd-swarm gateway base. Not set by default — content is reached
+     * via the indexer proxy (which fronts the swarm) and the cairn origin, both verified.
+     * Set this only if you run a public swarm gateway.
+     */
+    swarm?: string;
+}
+interface CairnConfig {
+    /** Currently only "mainnet". Selects the default base URLs. */
+    network?: "mainnet";
+    baseUrls?: CairnBaseUrls;
+    /** Custom fetch (defaults to global fetch). */
+    fetch?: FetchLike;
+    /** Per-request HTTP timeout in ms (default 15000). */
+    timeoutMs?: number;
+    /** A pre-connected wallet (otherwise call `cairn.connect()` in the browser). */
+    wallet?: WalletConnection;
+    /** WebSocket implementation for indexer subscriptions (defaults to global). */
+    WebSocketImpl?: typeof WebSocket;
+}
+declare class Cairn {
+    readonly config: CairnConfig;
+    readonly chain: Chain;
+    readonly index: IndexerClient;
+    readonly content: ContentClient;
+    readonly registry: RegistryClient;
+    board: BoardClient;
+    wallet?: WalletConnection;
+    private readonly cairnHttp;
+    constructor(config?: CairnConfig);
+    /**
+     * Detect + connect the Cairn Wallet (browser only). Wires the wallet into
+     * `cairn.board` for signed writes. Resolves to the connected address.
+     */
+    connect(opts?: DetectOptions): Promise<string>;
+    /** Attach an already-connected wallet (e.g. one you constructed yourself). */
+    attachWallet(wallet: WalletConnection): void;
+    /** True if a wallet is attached. */
+    get connected(): boolean;
+}
+
+export { BoardClient, Cairn, type CairnBaseUrls, type CairnConfig, CairnError, Chain, ContentClient, ContentVerificationError, DetectOptions, FetchLike, HttpError, IndexerClient, NotInstalledError, RegistryClient, UnsupportedMethodError, UserRejectedError, WalletConnection, WalletLockedError };

package/dist/index.js

@@ -0,0 +1,181 @@
+import {
+  BoardClient
+} from "./chunk-OGP2W7DL.js";
+import {
+  Chain
+} from "./chunk-6VWLWF7R.js";
+import {
+  WalletConnection,
+  connect,
+  detectProvider,
+  getWallet,
+  isInstalled
+} from "./chunk-SMAPCKVG.js";
+import {
+  ContentClient
+} from "./chunk-BZVJVL4Q.js";
+import {
+  CairnError,
+  ContentVerificationError,
+  HttpError,
+  NotInstalledError,
+  UnsupportedMethodError,
+  UserRejectedError,
+  WalletLockedError
+} from "./chunk-PHMU3CG5.js";
+import {
+  IndexerClient
+} from "./chunk-ETZYBDFC.js";
+import {
+  RegistryClient
+} from "./chunk-G7FABIF4.js";
+
+// src/http.ts
+var Http = class {
+  baseUrl;
+  _fetch;
+  timeoutMs;
+  headers;
+  constructor(opts) {
+    this.baseUrl = opts.baseUrl.replace(/\/+$/, "");
+    const f = opts.fetch ?? globalThis.fetch;
+    if (!f) throw new Error("No fetch available \u2014 pass `fetch` in the SDK options.");
+    this._fetch = opts.fetch ? opts.fetch : f.bind(globalThis);
+    this.timeoutMs = opts.timeoutMs ?? 15e3;
+    this.headers = opts.headers ?? {};
+  }
+  /** Build an absolute URL from a path + optional query params. */
+  url(path, query) {
+    const p = path.startsWith("/") ? path : `/${path}`;
+    const u = new URL(this.baseUrl + p);
+    if (query) {
+      for (const [k, v] of Object.entries(query)) {
+        if (v !== void 0 && v !== null) u.searchParams.set(k, String(v));
+      }
+    }
+    return u.toString();
+  }
+  async raw(method, path, opts) {
+    const url = this.url(path, opts?.query);
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), this.timeoutMs);
+    try {
+      const res = await this._fetch(url, {
+        method,
+        signal: ctrl.signal,
+        headers: {
+          ...opts?.body !== void 0 ? { "content-type": "application/json" } : {},
+          ...this.headers,
+          ...opts?.headers ?? {}
+        },
+        body: opts?.body !== void 0 ? JSON.stringify(opts.body) : void 0
+      });
+      return res;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async getJson(path, query) {
+    const res = await this.raw("GET", path, { query });
+    if (!res.ok) throw new HttpError(res.status, this.url(path, query), await safeText(res));
+    return await res.json();
+  }
+  async postJson(path, body, headers) {
+    const res = await this.raw("POST", path, { body, headers });
+    if (!res.ok) throw new HttpError(res.status, this.url(path), await safeText(res));
+    return await res.json();
+  }
+  /** GET raw bytes (for content retrieval). Returns null on 404. */
+  async getBytes(path) {
+    const res = await this.raw("GET", path);
+    if (res.status === 404) return null;
+    if (!res.ok) throw new HttpError(res.status, this.url(path), await safeText(res));
+    const buf = new Uint8Array(await res.arrayBuffer());
+    return { bytes: buf, headers: res.headers };
+  }
+};
+async function safeText(res) {
+  try {
+    return await res.text();
+  } catch {
+    return "";
+  }
+}
+
+// src/index.ts
+var DEFAULT_CAIRN = "https://cairn-substrate.com";
+var Cairn = class {
+  config;
+  chain;
+  index;
+  content;
+  registry;
+  board;
+  wallet;
+  cairnHttp;
+  constructor(config = {}) {
+    this.config = config;
+    const fetch = config.fetch;
+    const timeoutMs = config.timeoutMs;
+    const cairn = (config.baseUrls?.cairn ?? DEFAULT_CAIRN).replace(/\/+$/, "");
+    const rpc = config.baseUrls?.rpc ?? `${cairn}/api/rpc`;
+    const indexer = (config.baseUrls?.indexer ?? `${cairn}/explorer/api`).replace(/\/+$/, "");
+    this.cairnHttp = new Http({ baseUrl: cairn, fetch, timeoutMs });
+    const indexerHttp = new Http({ baseUrl: indexer, fetch, timeoutMs });
+    const swarmHttp = config.baseUrls?.swarm ? new Http({ baseUrl: config.baseUrls.swarm.replace(/\/+$/, ""), fetch, timeoutMs }) : void 0;
+    this.chain = new Chain({ rpcUrl: rpc, fetch, timeoutMs });
+    this.wallet = config.wallet;
+    this.board = new BoardClient(this.cairnHttp, this.wallet);
+    this.index = new IndexerClient(indexerHttp, {
+      fetch,
+      WebSocketImpl: config.WebSocketImpl,
+      // Upgrade inclusion proofs to fully trust-minimized by cross-checking the
+      // proof root against the on-chain header merkle at that height.
+      headerMerkleAt: async (h) => {
+        const block = await this.chain.client.blockByHeight(h);
+        return String(block.header.merkle);
+      }
+    });
+    this.content = new ContentClient({ swarm: swarmHttp, indexer: indexerHttp, cairn: this.cairnHttp });
+    this.registry = new RegistryClient({ baseUrl: indexer, fetch });
+  }
+  /**
+   * Detect + connect the Cairn Wallet (browser only). Wires the wallet into
+   * `cairn.board` for signed writes. Resolves to the connected address.
+   */
+  async connect(opts = {}) {
+    const { wallet, address } = await connect(opts);
+    this.attachWallet(wallet);
+    return address;
+  }
+  /** Attach an already-connected wallet (e.g. one you constructed yourself). */
+  attachWallet(wallet) {
+    this.wallet = wallet;
+    this.board = new BoardClient(this.cairnHttp, wallet);
+  }
+  /** True if a wallet is attached. */
+  get connected() {
+    return !!this.wallet;
+  }
+};
+export {
+  BoardClient,
+  Cairn,
+  CairnError,
+  Chain,
+  ContentClient,
+  ContentVerificationError,
+  Http,
+  HttpError,
+  IndexerClient,
+  NotInstalledError,
+  RegistryClient,
+  UnsupportedMethodError,
+  UserRejectedError,
+  WalletConnection,
+  WalletLockedError,
+  connect,
+  detectProvider,
+  getWallet,
+  isInstalled
+};

package/dist/indexer.cjs

@@ -0,0 +1,256 @@
+"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/indexer.ts
+var indexer_exports = {};
+__export(indexer_exports, {
+  IndexerClient: () => IndexerClient
+});
+module.exports = __toCommonJS(indexer_exports);
+var import_csd_codec = require("@inversealtruism/csd-codec");
+var IndexerClient = class {
+  http;
+  opts;
+  constructor(http, opts = {}) {
+    this.http = http;
+    this.opts = opts;
+  }
+  // ---- REST --------------------------------------------------------------
+  health() {
+    return this.http.getJson("/health");
+  }
+  tipHeight() {
+    return this.http.getJson("/blocks/tip/height");
+  }
+  tipHash() {
+    return this.http.getJson("/blocks/tip/hash");
+  }
+  blockHashAtHeight(h) {
+    return this.http.getJson(`/block-height/${h}`);
+  }
+  block(hash) {
+    return this.http.getJson(`/block/${hash}`);
+  }
+  blockTxids(hash) {
+    return this.http.getJson(`/block/${hash}/txids`);
+  }
+  tx(id) {
+    return this.http.getJson(`/tx/${id}`);
+  }
+  txStatus(id) {
+    return this.http.getJson(`/tx/${id}/status`);
+  }
+  txMerkleProof(id) {
+    return this.http.getJson(`/tx/${id}/merkle-proof`);
+  }
+  address(a) {
+    return this.http.getJson(`/address/${a}`);
+  }
+  addressTxs(a) {
+    return this.http.getJson(`/address/${a}/txs`);
+  }
+  addressUtxo(a) {
+    return this.http.getJson(`/address/${a}/utxo`);
+  }
+  reputation(a) {
+    return this.http.getJson(`/address/${a}/reputation`);
+  }
+  domains() {
+    return this.http.getJson("/domains");
+  }
+  domainProposals(d) {
+    return this.http.getJson(`/domain/${encodeURIComponent(d)}/proposals`);
+  }
+  proposal(id) {
+    return this.http.getJson(`/proposal/${id}`);
+  }
+  attestations(id) {
+    return this.http.getJson(`/proposal/${id}/attestations`);
+  }
+  registryPeers() {
+    return this.http.getJson("/registry/peers");
+  }
+  registryGateways() {
+    return this.http.getJson("/registry/gateways");
+  }
+  identity(handle) {
+    return this.http.getJson(`/identity/${encodeURIComponent(handle)}`);
+  }
+  reverseIdentity(addr) {
+    return this.http.getJson(`/address/${addr}/identity`);
+  }
+  // ---- trust-minimized inclusion ----------------------------------------
+  /**
+   * Verify a tx is included in a block by folding its merkle branch to the root
+   * with csd-codec.verifyMerkleProof. If `headerMerkleAt` was provided, the
+   * proof's root is cross-checked against the ON-CHAIN header merkle at that
+   * height → trustLevel "verified-inclusion". Otherwise the proof is only
+   * internally consistent → "proof-consistent" (still useful, but the indexer is trusted).
+   */
+  async verifyInclusion(txid) {
+    let proof;
+    try {
+      proof = await this.txMerkleProof(txid);
+    } catch {
+      return { included: false, trustLevel: "not-found", reason: "no merkle proof (tx not indexed)" };
+    }
+    const folds = (0, import_csd_codec.verifyMerkleProof)(txid, proof.pos, proof.merkle, proof.merkle_root);
+    if (!folds) {
+      return { included: false, trustLevel: "not-found", blockHeight: proof.block_height, reason: "merkle branch does not fold to the claimed root" };
+    }
+    if (this.opts.headerMerkleAt) {
+      try {
+        const onchain = await this.opts.headerMerkleAt(proof.block_height);
+        if (norm(onchain) !== norm(proof.merkle_root)) {
+          return { included: false, trustLevel: "not-found", blockHeight: proof.block_height, reason: "proof root != on-chain header merkle (indexer disagrees with chain)" };
+        }
+        return { included: true, trustLevel: "verified-inclusion", blockHeight: proof.block_height, pos: proof.pos, merkleRoot: proof.merkle_root };
+      } catch {
+      }
+    }
+    return { included: true, trustLevel: "proof-consistent", blockHeight: proof.block_height, pos: proof.pos, merkleRoot: proof.merkle_root };
+  }
+  // ---- live streams ------------------------------------------------------
+  /** Stream all events (blocks, proposals, attestations, reorgs) via SSE. */
+  streamAll(handlers) {
+    return this.sse("/stream/all", handlers);
+  }
+  /** Stream blocks + reorgs only. */
+  streamBlocks(handlers) {
+    return this.sse("/stream/blocks", handlers);
+  }
+  /** Stream proposals (+ reorgs) for a domain. */
+  streamDomain(domain, handlers) {
+    return this.sse(`/stream/domain/${encodeURIComponent(domain)}`, handlers);
+  }
+  /**
+   * Subscribe over WebSocket with selective tracking. Returns a handle with
+   * `.close()`. `onEvent` receives every matching IndexEvent (incl. reorgs).
+   */
+  subscribe(sub, onEvent, onError) {
+    const WS = this.opts.WebSocketImpl ?? globalThis.WebSocket;
+    if (!WS) {
+      throw new Error("No WebSocket available \u2014 pass WebSocketImpl in the indexer options (e.g. in older Node).");
+    }
+    const wsUrl = this.http.url("/ws").replace(/^http/, "ws");
+    let closed = false;
+    const ws = new WS(wsUrl);
+    ws.addEventListener("open", () => {
+      const msg = {};
+      if (sub.all) msg["track-all"] = true;
+      if (sub.domains?.length) msg["track-domain"] = sub.domains;
+      if (sub.addresses?.length) msg["track-address"] = sub.addresses;
+      if (sub.proposals?.length) msg["track-proposal"] = sub.proposals;
+      ws.send(JSON.stringify(Object.keys(msg).length ? msg : { "track-all": true }));
+    });
+    ws.addEventListener("message", (ev) => {
+      try {
+        const data = JSON.parse(typeof ev.data === "string" ? ev.data : String(ev.data));
+        if (data && data.kind) onEvent(data);
+      } catch {
+      }
+    });
+    if (onError) ws.addEventListener("error", (e) => onError(e));
+    return {
+      close() {
+        if (closed) return;
+        closed = true;
+        try {
+          ws.close();
+        } catch {
+        }
+      }
+    };
+  }
+  // ---- internal SSE over fetch (portable + auto-reconnect) ---------------
+  sse(path, handlers) {
+    const fetchImpl = this.opts.fetch ?? globalThis.fetch;
+    const url = this.http.url(path);
+    let closed = false;
+    let ctrl = null;
+    const run = async () => {
+      while (!closed) {
+        ctrl = new AbortController();
+        try {
+          const res = await fetchImpl(url, { signal: ctrl.signal, headers: { accept: "text/event-stream" } });
+          if (!res.ok || !res.body) throw new Error(`SSE ${res.status}`);
+          handlers.onOpen?.();
+          const reader = res.body.getReader();
+          const decoder = new TextDecoder();
+          let buf = "";
+          for (; ; ) {
+            const { value, done } = await reader.read();
+            if (done) break;
+            buf += decoder.decode(value, { stream: true });
+            let idx;
+            while ((idx = buf.indexOf("\n\n")) >= 0) {
+              const frame = buf.slice(0, idx);
+              buf = buf.slice(idx + 2);
+              dispatchFrame(frame, handlers);
+            }
+          }
+        } catch (err) {
+          if (closed) return;
+          handlers.onError?.(err);
+        }
+        if (closed) return;
+        await new Promise((r) => setTimeout(r, 2e3));
+      }
+    };
+    void run();
+    return {
+      close() {
+        if (closed) return;
+        closed = true;
+        try {
+          ctrl?.abort();
+        } catch {
+        }
+      }
+    };
+  }
+};
+function dispatchFrame(frame, h) {
+  let event = "message";
+  const dataLines = [];
+  for (const line of frame.split("\n")) {
+    if (line.startsWith(":")) continue;
+    if (line.startsWith("event:")) event = line.slice(6).trim();
+    else if (line.startsWith("data:")) dataLines.push(line.slice(5).trim());
+  }
+  if (event === "hello" || dataLines.length === 0) return;
+  let parsed;
+  try {
+    parsed = JSON.parse(dataLines.join("\n"));
+  } catch {
+    return;
+  }
+  h.onEvent?.(parsed);
+  if (parsed.kind === "block") h.onBlock?.(parsed);
+  else if (parsed.kind === "proposal") h.onProposal?.(parsed);
+  else if (parsed.kind === "attestation") h.onAttestation?.(parsed);
+  else if (parsed.kind === "reorg") h.onReorg?.(parsed);
+}
+function norm(h) {
+  return String(h).toLowerCase().replace(/^0x/, "");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  IndexerClient
+});