@mikeargento/bitgraph-mcp 0.6.0 → 0.7.0

package/src/server.ts

@@ -19,24 +19,17 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import type { RequestHandlerExtra } from "@modelcontextprotocol/sdk/shared/protocol.js";
 import type { ServerNotification, ServerRequest } from "@modelcontextprotocol/sdk/types.js";
 import { z } from "zod";
-import { readFile } from "node:fs/promises";
-import { FuseError, MAX_SET_MEMBERS, builderFor, fuse, fuseSet, fusedNamesFor, type FuseSetMember, type FuseSetProgress } from "@mikeargento/bitgraph";
+import { FuseError, MAX_SET_MEMBERS, type FuseSetProgress } from "@mikeargento/bitgraph";
 import {
-  ApiError,
-  batchCheck,
-  configFromEnv,
-  getProofDetail,
-  indexSetMembers,
-  search,
-  type ApiConfig,
-} from "./api.js";
-import {
-  fromUrlSafeB64,
-  looksLikeDigest,
-  mapConcurrent,
-  sha256FileB64,
-  toUrlSafeB64,
-} from "./encoding.js";
+  ApiError, batchCheck, configFromEnv, getProofDetail, indexSetMembers, search, type ApiConfig,
+  fromUrlSafeB64, looksLikeDigest, mapConcurrent, sha256FileB64, toUrlSafeB64,
+  expandPaths, scanFile, type ScannedFile,
+  type CarrierWindowView,
+  classifyPath, fuseFilePipeline, fuseSetPipeline, MAX_LOADED_BYTES,
+  type CarrierRow, type FuseFileFn, type FuseSetFn, type FusedSummary, type SetSummary,
+  SLOT_TTL_SECONDS, beginTask, decodeTaskToken, sealTask, writeProofBeside,
+  type BitGraphProof, type ProofDetailResponse,
+} from "@mikeargento/bitgraph-sdk";
 import {
   capJson,
   positionOf,
@@ -48,13 +41,11 @@ import {
   type RecordOutcome,
   type SetOutcome,
 } from "./format.js";
-import { expandPaths, fusedDigestFor, scanFile, sniffC2paBytes, type ScannedFile } from "./scan.js";
-import { readCarrierFile, sniffCarrierTail, type CarrierWindowView } from "./carrier-io.js";
-import { stat } from "node:fs/promises";
-import { SLOT_TTL_SECONDS, TASK_INSTRUCTIONS, beginTask, decodeTaskToken, sealTask, writeProofBeside } from "./task.js";
-import type { BitGraphProof, ProofDetailResponse } from "./types.js";
+import { TASK_INSTRUCTIONS } from "./instructions.js";
+
+export type { FuseFileFn, FuseSetFn, FusedSummary, SetSummary } from "@mikeargento/bitgraph-sdk";
 
-export const SERVER_VERSION = "0.6.0";
+export const SERVER_VERSION = "0.7.0";
 
 const SCAN_CONCURRENCY = 4;
 /** Paths per call; a directory counts once and expands to its files. */
@@ -64,7 +55,6 @@ export const MAX_MEMBERS = 100_000;
 /** Files one check may cover after directories expand. */
 const MAX_CHECK_FILES = 10_000;
 /** A file whose length changed while it was read is fused from its bytes instead; above this it is left out rather than held in memory. */
-const MAX_LOADED_BYTES = 256 * 1024 * 1024;
 /** A single file up to this size is fused on its own, in memory, with its Frame; a larger one is a set of one, never held. */
 const MAX_SOLO_BYTES = 256 * 1024 * 1024;
 /** Rows the structured result lists in full; every fused row shares the set's position. */
@@ -73,42 +63,6 @@ export const ROW_CAP = 500;
 export const SET_INDEX_CHUNK = 2500;
 
 /** What one set yields, in the shape the tool reports; tests inject a stand-in. */
-export interface SetSummary {
-  set: "set/1" | "set/2";
-  proof: BitGraphProof;
-  /** Standard base64: the committed artifact's digest. */
-  artifactDigestB64: string;
-  count: number;
-  manifestEchoed: boolean;
-  recovered: boolean;
-  /** In the order the files were given. */
-  members: Array<{
-    index: number;
-    /** The row's ordinal in the committed artifact. */
-    manifestIndex: number;
-    placement: string;
-    originDigestB64: string;
-    artifactDigestB64: string;
-    /** set/2 only: the member's evidence, for the site's index. */
-    memberProof?: unknown;
-  }>;
-}
-export type FuseSetFn = (
-  files: readonly ScannedFile[],
-  config: ApiConfig,
-  opts: { set: "set/1" | "set/2"; onProgress?: (p: FuseSetProgress) => void }
-) => Promise<SetSummary>;
-
-/** What fusing one file on its own yields. */
-export interface FusedSummary {
-  proof: BitGraphProof;
-  frame: unknown;
-  placement: string;
-  artifactDigestB64: string;
-  originDigestB64: string;
-}
-export type FuseFileFn = (file: ScannedFile, config: ApiConfig) => Promise<FusedSummary>;
-
 export interface ServerDeps {
   /** The set pipeline; tests inject a stand-in. Default: the core package's fuseSet() against the configured site. */
   fuseSet?: FuseSetFn;
@@ -116,121 +70,6 @@ export interface ServerDeps {
   fuseFile?: FuseFileFn;
 }
 
-/**
- * A single file, the way a single drop on the site goes: the bytes in hand,
- * the placement chosen from them, one slot, the fused bytes built in memory
- * and hashed, committed under that exact slot, verified against the bytes,
- * and a Frame returned. The fused bytes are not kept.
- */
-async function fuseFileDefault(file: ScannedFile, config: ApiConfig): Promise<FusedSummary> {
-  const bytes = new Uint8Array(await readFile(file.path));
-  const placement = file.placement;
-  const { fusedName } = fusedNamesFor(file.name, placement);
-  const r = await fuse(builderFor(placement, bytes), {
-    placement,
-    original: bytes,
-    fusedFile: fusedName,
-    keepFused: false,
-    transport: { baseUrl: config.baseUrl, ...(config.apiKey ? { apiKey: config.apiKey } : {}) },
-  });
-  return {
-    proof: r.proof as unknown as BitGraphProof,
-    frame: r.frame,
-    placement,
-    artifactDigestB64: r.artifactDigestB64,
-    originDigestB64: r.originDigestB64 ?? file.digestB64,
-  };
-}
-
-/**
- * The default pipeline, the one the site's drop runs: one slot for the set,
- * every member a hashed member whose fused digest is finished from the
- * scan's open hasher with its placement's suffix for that slot, the set's
- * manifest (or, for a set/2, its root document) committed under the same
- * slot, and the returned proof verified against the committed artifact with
- * every member bound to it by digest. A file whose length changed during the
- * scan is a loaded member: read again when it is its turn, checked against
- * the scan's digest, fused in memory, hashed and released.
- */
-async function fuseSetDefault(
-  files: readonly ScannedFile[],
-  config: ApiConfig,
-  opts: { set: "set/1" | "set/2"; onProgress?: (p: FuseSetProgress) => void }
-): Promise<SetSummary> {
-  const members: FuseSetMember[] = files.map((f) =>
-    f.state !== null
-      ? { originDigest: f.originDigest, placement: f.placement, name: f.name, fusedDigest: ({ commitment }) => fusedDigestFor(f, commitment) }
-      : { load: async () => new Uint8Array(await readFile(f.path)), originDigest: f.originDigest, placement: f.placement, name: f.name }
-  );
-  const r = await fuseSet(members, {
-    set: opts.set,
-    keepFused: false,
-    ...(opts.onProgress !== undefined ? { onProgress: opts.onProgress } : {}),
-    transport: { baseUrl: config.baseUrl, ...(config.apiKey ? { apiKey: config.apiKey } : {}) },
-  });
-  return {
-    set: r.set,
-    proof: r.proof as unknown as BitGraphProof,
-    artifactDigestB64: r.artifactDigestB64,
-    count: r.members.length,
-    manifestEchoed: r.manifestEchoed,
-    recovered: r.recovered,
-    members: r.members.map((m) => ({
-      index: m.index,
-      manifestIndex: m.manifestIndex,
-      placement: m.placement,
-      originDigestB64: m.originDigestB64,
-      artifactDigestB64: m.artifactDigestB64,
-      ...(m.memberProof !== undefined ? { memberProof: m.memberProof } : {}),
-    })),
-  };
-}
-
-/**
- * A path is either plain bytes to scan or a BitGraphed file (bitgraph-carrier/1),
- * decided by one 8-byte tail read. A BitGraphed file is judged OFFLINE from the
- * proof it carries, its lookups use the digest of the committed bytes inside,
- * and it is never minted: the envelope is not the recorded thing, the bytes
- * inside are. That is the same structural guarantee the site's drop box gives.
- */
-interface CarrierRow {
-  kind: "carrier";
-  path: string;
-  status: "ok" | "corrupt" | "too-large";
-  /** Standard base64 SHA-256 of the committed bytes inside (status "ok"). */
-  innerDigestB64: string | null;
-  view: CarrierWindowView | null;
-  /** The carried bitgraph/1 proof, for offline answers when the ledger has no row. */
-  proof: unknown | null;
-  c2pa: boolean;
-  reason: string | null;
-}
-type ClassifiedPath = { kind: "plain"; file: ScannedFile } | CarrierRow;
-
-async function classifyPath(p: string): Promise<ClassifiedPath> {
-  const info = await stat(p);
-  if (info.isFile() && (await sniffCarrierTail(p, info.size))) {
-    if (info.size > MAX_LOADED_BYTES) {
-      return {
-        kind: "carrier", path: p, status: "too-large", innerDigestB64: null, view: null, proof: null, c2pa: false,
-        reason: `a BitGraphed file larger than this tool loads (${Math.round(MAX_LOADED_BYTES / (1024 * 1024))} MiB); judge it offline with: npx @mikeargento/bitgraph-audit "${p}"`,
-      };
-    }
-    const r = await readCarrierFile(p);
-    if (r.status === "corrupt" || r.innerDigestB64 === null) {
-      return {
-        kind: "carrier", path: p, status: "corrupt", innerDigestB64: null, view: null, proof: null, c2pa: false,
-        reason: `a carrier block was found at the end of the file but is unreadable: ${r.corruptReason ?? "unspecified"}. A corrupted block, not a forgery; nothing was minted for it.`,
-      };
-    }
-    return {
-      kind: "carrier", path: p, status: "ok", innerDigestB64: r.innerDigestB64, view: r.view,
-      proof: r.result?.payload?.proof ?? null, c2pa: r.inner !== null && sniffC2paBytes(r.inner), reason: null,
-    };
-  }
-  return { kind: "plain", file: await scanFile(p) };
-}
-
 /** Hash the given paths (bounded concurrency). Throws before any network call. */
 async function hashPaths(paths: readonly string[]): Promise<string[]> {
   const failures: string[] = [];
@@ -370,8 +209,8 @@ async function flushIndex(config: ApiConfig, report: Report): Promise<{ written:
 }
 
 export function buildServer(deps: ServerDeps = {}): McpServer {
-  const fuseSetPipeline = deps.fuseSet ?? fuseSetDefault;
-  const fuseFilePipeline = deps.fuseFile ?? fuseFileDefault;
+  const runFuseSet = deps.fuseSet ?? fuseSetPipeline;
+  const runFuseFile = deps.fuseFile ?? fuseFilePipeline;
   const server = new McpServer(
     {
       name: "bitgraph-mcp-server",
@@ -501,14 +340,14 @@ export function buildServer(deps: ServerDeps = {}): McpServer {
           // One file, as a single drop on the site goes: its own slot, its own Frame.
           report(0, 1, "fusing");
           try {
-            solo = { ...(await fuseFilePipeline(one, config)), file: one };
+            solo = { ...(await runFuseFile(one, config)), file: one };
           } catch (err) {
             failure = setFailureText(err);
           }
         } else if (toMint.length > 0) {
           const kind: "set/1" | "set/2" = toMint.length > MAX_SET_MEMBERS ? "set/2" : "set/1";
           try {
-            made = await fuseSetPipeline(toMint, config, {
+            made = await runFuseSet(toMint, config, {
               set: kind,
               onProgress: (p) => report(p.done, p.total, `${PHASES[p.phase]} ${p.done} of ${p.total}`),
             });

package/src/__tests__/encoding.test.ts

@@ -1,64 +0,0 @@
-// Copyright (c) 2024-2026 Argento Computing Inc. Licensed under the MIT License. See LICENSE.
-
-import { test } from "node:test";
-import { strict as assert } from "node:assert";
-import { createHash } from "node:crypto";
-import { writeFile, mkdtemp } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import {
-  fromUrlSafeB64,
-  looksLikeDigest,
-  mapConcurrent,
-  sha256FileB64,
-  toUrlSafeB64,
-} from "../encoding.js";
-
-// A real 32-byte digest with + and / to exercise both substitutions.
-const STANDARD = createHash("sha256").update("bitgraph").digest("base64");
-
-test("url-safe round trip preserves the digest", () => {
-  const safe = toUrlSafeB64(STANDARD);
-  assert.ok(!safe.includes("+") && !safe.includes("/") && !safe.includes("="));
-  assert.equal(fromUrlSafeB64(safe), STANDARD);
-});
-
-test("fromUrlSafeB64 is a no-op on standard base64", () => {
-  assert.equal(fromUrlSafeB64(STANDARD), STANDARD);
-});
-
-test("looksLikeDigest accepts both forms, rejects junk", () => {
-  assert.ok(looksLikeDigest(STANDARD));
-  assert.ok(looksLikeDigest(toUrlSafeB64(STANDARD)));
-  assert.ok(!looksLikeDigest("not-a-digest"));
-  assert.ok(!looksLikeDigest(""));
-  assert.ok(!looksLikeDigest(Buffer.alloc(16).toString("base64"))); // 16 bytes, not 32
-});
-
-test("sha256FileB64 matches crypto over the same bytes", async () => {
-  const dir = await mkdtemp(join(tmpdir(), "bitgraph-mcp-"));
-  const file = join(dir, "sample.bin");
-  const bytes = Buffer.from("BitGraph proves causal ordering.\n");
-  await writeFile(file, bytes);
-  const expected = createHash("sha256").update(bytes).digest("base64");
-  assert.equal(await sha256FileB64(file), expected);
-});
-
-test("sha256FileB64 rejects directories and missing files", async () => {
-  await assert.rejects(() => sha256FileB64(tmpdir()), /Not a regular file/);
-  await assert.rejects(() => sha256FileB64(join(tmpdir(), "definitely-missing-9x7")));
-});
-
-test("mapConcurrent preserves order and honors the limit", async () => {
-  let inFlight = 0;
-  let peak = 0;
-  const out = await mapConcurrent([1, 2, 3, 4, 5, 6, 7, 8], 3, async (n) => {
-    inFlight += 1;
-    peak = Math.max(peak, inFlight);
-    await new Promise((r) => setTimeout(r, 5));
-    inFlight -= 1;
-    return n * 2;
-  });
-  assert.deepEqual(out, [2, 4, 6, 8, 10, 12, 14, 16]);
-  assert.ok(peak <= 3, `peak concurrency ${peak} exceeded 3`);
-});

package/src/__tests__/scan.test.ts

@@ -1,80 +0,0 @@
-// Copyright (c) 2024-2026 Argento Computing Inc. Licensed under the MIT License. See LICENSE.
-
-/**
- * The scan's two promises: the digest is the file's own, and a state
- * finished with the placement's suffix for a slot is the hash of the
- * placement's own build for that slot. Both are pinned across sizes on both
- * sides of every boundary that matters (the 64-byte sniff, the tar block,
- * the 64 KB stream chunk) for both placements the scan makes.
- */
-
-import { test, before } from "node:test";
-import { strict as assert } from "node:assert";
-import { createHash, randomBytes } from "node:crypto";
-import { mkdtemp, mkdir, symlink, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { placementForBytes } from "@mikeargento/bitgraph";
-import { getPlacement } from "@mikeargento/bitgraph-verify";
-import { expandPaths, fusedDigestFor, scanFile } from "../scan.js";
-
-let root = "";
-before(async () => {
-  root = await mkdtemp(join(tmpdir(), "bitgraph-mcp-scan-"));
-});
-
-const PNG = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
-const SIZES = [0, 1, 8, 63, 64, 65, 511, 512, 513, 1024, 65_535, 65_536, 65_537, 200_000];
-
-test("a scan's digest is the file's own and its state finishes to the placement's own build", async () => {
-  let checked = 0;
-  for (const size of SIZES) {
-    for (const kind of ["png", "txt"] as const) {
-      const lead = kind === "png" ? PNG : Buffer.from("txt:");
-      const bytes = Buffer.concat([lead, randomBytes(Math.max(0, size - lead.length))]).subarray(0, size);
-      const path = join(root, `${kind}-${size}.bin`);
-      await writeFile(path, bytes);
-      const s = await scanFile(path);
-      assert.equal(s.size, size);
-      assert.equal(s.digestB64, createHash("sha256").update(bytes).digest("base64"), `${kind} ${size}: digest`);
-      assert.equal(s.placement, placementForBytes(new Uint8Array(bytes)), `${kind} ${size}: the core's own placement choice`);
-      assert.ok(s.state !== null, "a file that did not change keeps its state");
-      const placement = getPlacement(s.placement);
-      if (placement === undefined) throw new Error("placement missing");
-      // Two slots, both finished from the same saved state: the copy leaves the state intact.
-      for (const commitment of [randomBytes(32), randomBytes(32)]) {
-        const built = placement.build({ original: new Uint8Array(bytes), originDigest: s.originDigest, commitment: new Uint8Array(commitment) });
-        const expected = createHash("sha256").update(built).digest();
-        assert.deepEqual(Buffer.from(fusedDigestFor(s, new Uint8Array(commitment))), expected, `${kind} ${size}: state finished == sha256(build)`);
-        checked += 1;
-      }
-    }
-  }
-  assert.equal(checked, SIZES.length * 4);
-});
-
-test("expandPaths: files, directories, hidden entries, links, duplicates, limits, missing paths", async () => {
-  const lone = join(root, "lone.txt");
-  await writeFile(lone, "lone");
-  const dir = join(root, "tree");
-  await mkdir(join(dir, "sub", ".secret"), { recursive: true });
-  await writeFile(join(dir, "a.txt"), "a");
-  await writeFile(join(dir, ".DS_Store"), "junk");
-  await writeFile(join(dir, "sub", "b.txt"), "b");
-  await writeFile(join(dir, "sub", ".secret", "c.txt"), "c");
-  await symlink(join(dir, "a.txt"), join(dir, "link.txt"));
-
-  const e = await expandPaths([lone, dir], 100);
-  assert.deepEqual(e.files, [lone, join(dir, "a.txt"), join(dir, "sub", "b.txt")]);
-  assert.equal(e.directories, 1);
-
-  const twice = await expandPaths([lone, lone, dir, join(dir, "a.txt")], 100);
-  assert.deepEqual(twice.files, [lone, join(dir, "a.txt"), join(dir, "sub", "b.txt")], "the same file twice is one file");
-
-  await assert.rejects(expandPaths([dir], 1), /more than 1 files/);
-  await assert.rejects(expandPaths([lone, join(root, "missing.txt")], 100), (err: Error) => {
-    assert.ok(err.message.includes("nothing was BitGraphed"));
-    assert.ok(err.message.includes(join(root, "missing.txt")));
-    return true;
-  });
-});

package/src/api.ts

@@ -1,170 +0,0 @@
-// Copyright (c) 2024-2026 Argento Computing Inc. Licensed under the MIT License. See LICENSE.
-
-/**
- * @mikeargento/bitgraph-mcp: HTTP client for the hosted BitGraph API.
- *
- * The reads: the batch lookup, the proof detail, the number search. Making a
- * BitGraph goes through the core package's own transport against the same
- * site (its /api/fuse routes), which is what maintains the per-position
- * by-digest index that makes every member of a set discoverable afterward;
- * the one write here is a set/2's member evidence, indexed after the commit.
- */
-
-import { mapConcurrent } from "./encoding.js";
-import type { BatchCheckResponse, ProofDetailResponse, SearchResponse, SetIndexResponse } from "./types.js";
-
-export interface ApiConfig {
-  baseUrl: string;
-  apiKey?: string;
-}
-
-/** Read configuration from the environment at call time (testable via env). */
-export function configFromEnv(): ApiConfig {
-  const baseUrl = (process.env["BITGRAPH_API_URL"] ?? "https://bitgraph.ing").replace(/\/+$/, "");
-  const apiKey = process.env["BITGRAPH_API_KEY"];
-  return apiKey ? { baseUrl, apiKey } : { baseUrl };
-}
-
-/** Matches the batch endpoint's MAX_DIGESTS. */
-export const BATCH_CHECK_LIMIT = 500;
-/** Batch lookups in flight at once: a large folder is many pages. */
-const BATCH_CHECK_CONCURRENCY = 4;
-
-const CHECK_TIMEOUT_MS = 30_000;
-const SET_INDEX_TIMEOUT_MS = 60_000;
-
-export class ApiError extends Error {
-  readonly status: number;
-  readonly retryAfterSec: number | null;
-
-  constructor(status: number, message: string, retryAfterSec: number | null = null) {
-    super(message);
-    this.status = status;
-    this.retryAfterSec = retryAfterSec;
-  }
-}
-
-async function parseError(res: Response): Promise<ApiError> {
-  let message = res.statusText || `HTTP ${res.status}`;
-  try {
-    const body = (await res.json()) as { error?: string };
-    if (typeof body.error === "string" && body.error.length > 0) message = body.error;
-  } catch {
-    /* non-JSON error body */
-  }
-  const retryAfterRaw = res.headers.get("retry-after");
-  const retryAfterSec = retryAfterRaw !== null ? Number.parseInt(retryAfterRaw, 10) : null;
-  return new ApiError(res.status, message, Number.isFinite(retryAfterSec) ? retryAfterSec : null);
-}
-
-/**
- * Redirects are refused everywhere: an Authorization header must never follow
- * one to a different host, and the canonical endpoint serves without them.
- */
-function redirectHint(err: unknown): never {
-  if (err instanceof TypeError && /redirect/i.test(err.message)) {
-    throw new Error(
-      "The BitGraph endpoint redirected. Set BITGRAPH_API_URL to the canonical https://bitgraph.ing (apex, no www)."
-    );
-  }
-  throw err;
-}
-
-async function getJson<T>(config: ApiConfig, path: string, timeoutMs: number): Promise<T> {
-  const res = await fetch(`${config.baseUrl}${path}`, {
-    method: "GET",
-    redirect: "error",
-    signal: AbortSignal.timeout(timeoutMs),
-  }).catch(redirectHint);
-  if (!res.ok) throw await parseError(res);
-  return (await res.json()) as T;
-}
-
-async function postJson<T>(
-  config: ApiConfig,
-  path: string,
-  body: unknown,
-  timeoutMs: number,
-  authenticated: boolean
-): Promise<T> {
-  const headers: Record<string, string> = { "Content-Type": "application/json" };
-  if (authenticated && config.apiKey) headers["Authorization"] = `Bearer ${config.apiKey}`;
-  const res = await fetch(`${config.baseUrl}${path}`, {
-    method: "POST",
-    headers,
-    body: JSON.stringify(body),
-    redirect: "error",
-    signal: AbortSignal.timeout(timeoutMs),
-  }).catch(redirectHint);
-  if (!res.ok) throw await parseError(res);
-  return (await res.json()) as T;
-}
-
-/**
- * Look up which digests are on record. Input digests must be URL-safe base64;
- * the response is keyed by the exact strings sent. Pages of up to 500, a few
- * in flight at once.
- */
-export async function batchCheck(
-  config: ApiConfig,
-  urlSafeDigests: readonly string[]
-): Promise<BatchCheckResponse> {
-  const chunks: string[][] = [];
-  for (let offset = 0; offset < urlSafeDigests.length; offset += BATCH_CHECK_LIMIT) {
-    chunks.push(urlSafeDigests.slice(offset, offset + BATCH_CHECK_LIMIT));
-  }
-  const pages = await mapConcurrent(chunks, BATCH_CHECK_CONCURRENCY, (chunk) =>
-    postJson<BatchCheckResponse>(config, "/api/proofs/batch", { digests: chunk }, CHECK_TIMEOUT_MS, false)
-  );
-  const merged: BatchCheckResponse = { results: {} };
-  for (const page of pages) Object.assign(merged.results, page.results);
-  return merged;
-}
-
-/** One request's worth of a set/2's member evidence, for the site to index. */
-export interface SetIndexRequest {
-  /** The set proof's artifact digest, URL-safe base64. */
-  setDigest: string;
-  /** The set proof's epoch id, URL-safe base64. */
-  epoch: string;
-  /** The set proof's commit counter. */
-  counter: string;
-  members: unknown[];
-}
-
-/**
- * Index members of a set/2 from their evidence. The site reads the set proof
- * from its own position, binds the root document, and checks every member's
- * path before writing a key; a row that does not bind is rejected, never
- * written.
- */
-export async function indexSetMembers(config: ApiConfig, body: SetIndexRequest): Promise<SetIndexResponse> {
-  return postJson<SetIndexResponse>(config, "/api/fuse/set-index", body, SET_INDEX_TIMEOUT_MS, false);
-}
-
-/** Full detail for one digest: proof, all causal positions, anchor window. */
-export async function getProofDetail(
-  config: ApiConfig,
-  urlSafeDigest: string,
-  counter?: string,
-  urlSafeEpoch?: string
-): Promise<ProofDetailResponse> {
-  const params = new URLSearchParams();
-  if (counter !== undefined) params.set("counter", counter);
-  if (urlSafeEpoch !== undefined) params.set("epoch", urlSafeEpoch);
-  const query = params.size > 0 ? `?${params.toString()}` : "";
-  return getJson<ProofDetailResponse>(
-    config,
-    `/api/proofs/digest/${encodeURIComponent(urlSafeDigest)}${query}`,
-    CHECK_TIMEOUT_MS
-  );
-}
-
-/** Resolve a BitGraph number (or digest string) to a digest via /api/search. */
-export async function search(config: ApiConfig, q: string): Promise<SearchResponse> {
-  return getJson<SearchResponse>(
-    config,
-    `/api/search?q=${encodeURIComponent(q)}`,
-    CHECK_TIMEOUT_MS
-  );
-}