@totemsdk/proofgraph 1.0.0 → 1.1.0

package/dist/cjs/replicated-evidence.js

@@ -0,0 +1,98 @@
+"use strict";
+/**
+ * RFC-057 Phase 4 — replicated proofgraph evidence adapter.
+ *
+ * Keeps the authoritative proofgraph evidence store local while allowing a
+ * replicated index to locate the same digest-verified artifacts on other
+ * peers. The replicated index is never trusted for bytes: every read
+ * re-verifies the artifact digest.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createReplicatedProofGraphEvidenceStore = createReplicatedProofGraphEvidenceStore;
+const core_1 = require("@totemsdk/core");
+const errors_1 = require("@totemsdk/storage/errors");
+const KEY_PREFIX = 'proofgraph:evidence:';
+const DEFAULT_NAMESPACE = 'totem-proofgraph-evidence';
+function normalizeHash(value) {
+    return value.replace(/^0x/i, '').toLowerCase();
+}
+function evidenceNodes(graph) {
+    return graph.nodes.filter((node) => node.type === 'evidence');
+}
+function contentHashOf(node) {
+    const value = node.data?.contentHash;
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function createReplicatedProofGraphEvidenceStore(options) {
+    if (!options.artifacts.capabilities.writable) {
+        throw new Error('replicated evidence store requires a writable artifact store');
+    }
+    const namespace = options.namespace ?? DEFAULT_NAMESPACE;
+    const key = (nodeId) => `${KEY_PREFIX}${nodeId}`;
+    return {
+        async putEvidence(graph, bytesFor) {
+            const refs = [];
+            for (const node of evidenceNodes(graph)) {
+                const bytes = bytesFor(node.id);
+                if (!bytes)
+                    continue;
+                const digest = (0, core_1.toHex)((0, core_1.sha3_256)(bytes));
+                const contentHash = contentHashOf(node);
+                if (contentHash && normalizeHash(contentHash) !== digest) {
+                    throw new errors_1.StorageError(`evidence commitment mismatch for node "${node.id}"`, 'corrupt', {
+                        key: key(node.id),
+                    });
+                }
+                const receipt = await options.artifacts.put(namespace, bytes);
+                if (contentHash && normalizeHash(contentHash) !== receipt.ref.digest) {
+                    throw new errors_1.StorageError(`artifact digest mismatch for node "${node.id}"`, 'corrupt', {
+                        key: key(node.id),
+                    });
+                }
+                await options.index.put(key(node.id), {
+                    nodeId: node.id,
+                    ref: receipt.ref,
+                    contentHash: contentHash ?? receipt.ref.digest,
+                    storedAt: Date.now(),
+                });
+                refs.push(receipt.ref);
+            }
+            return refs;
+        },
+        async getEvidence(nodeId) {
+            const raw = await options.index.get(key(nodeId));
+            if (!raw)
+                return { nodeId, status: 'not-found' };
+            const entry = raw;
+            const read = await options.artifacts.get(entry.ref);
+            if (read.status !== 'ok' || !read.bytes) {
+                return {
+                    nodeId,
+                    status: read.status,
+                    ref: entry.ref,
+                    ...(read.message ? { message: read.message } : {}),
+                };
+            }
+            const digest = (0, core_1.toHex)((0, core_1.sha3_256)(read.bytes));
+            if (normalizeHash(entry.contentHash) !== digest) {
+                return {
+                    nodeId,
+                    status: 'corrupt',
+                    ref: entry.ref,
+                    message: `evidence digest mismatch: ${digest} !== ${entry.contentHash}`,
+                };
+            }
+            return { nodeId, status: 'ok', ref: entry.ref, bytes: read.bytes };
+        },
+        async verifyEvidence(nodeId) {
+            return (await this.getEvidence(nodeId)).status === 'ok';
+        },
+        async *listEvidence() {
+            if (!options.index.list)
+                return;
+            for await (const entry of options.index.list(KEY_PREFIX)) {
+                yield entry.value;
+            }
+        },
+    };
+}

package/dist/cjs/types.d.ts

@@ -0,0 +1,62 @@
+/**
+ * @totemsdk/proofgraph — Type definitions
+ *
+ * Pure schema — no network, no DHT, no blockchain submission, no crypto.
+ */
+export type ProofGraphNodeType = 'proof' | 'identity' | 'identity-claim' | 'manifest' | 'address' | 'subject' | 'evidence' | 'anchor' | 'receipt' | 'payment' | 'device' | 'service' | 'policy' | 'custom';
+export type ProofGraphEdgeType = 'proves' | 'issued_by' | 'signed_by' | 'about' | 'references' | 'derived_from' | 'supports' | 'contradicts' | 'supersedes' | 'revokes' | 'anchored_to' | 'delegates_to' | 'controls' | 'depends_on' | 'manifests_as' | 'revision_of' | 'conflicts_with';
+export interface ProofGraphNode {
+    id: string;
+    type: ProofGraphNodeType;
+    refId: string;
+    data?: Record<string, unknown>;
+    createdAt: number;
+}
+export interface ProofGraphEdge {
+    id: string;
+    type: ProofGraphEdgeType;
+    from: string;
+    to: string;
+    proofId?: string;
+    data?: Record<string, unknown>;
+}
+export interface ProofGraph {
+    graphId: string;
+    nodes: ProofGraphNode[];
+    edges: ProofGraphEdge[];
+    createdAt: number;
+    metadata?: Record<string, unknown>;
+}
+export interface ProofGraphVerifyResult {
+    valid: boolean;
+    invalidProofs: string[];
+    reason?: string;
+}
+/**
+ * Input object for addReceiptLike.
+ */
+export interface ReceiptLikeInput {
+    id: string;
+    data?: Record<string, unknown>;
+    proofId?: string;
+}
+/**
+ * Input object for addAnchor.
+ */
+export interface AnchorInput {
+    hash: string;
+    provider?: string;
+    txId?: string;
+    confirmedAt?: number;
+    metadata?: Record<string, unknown>;
+    proofId?: string;
+}
+/**
+ * Storage port — interface only, no concrete implementation in this package.
+ * Adapters (SQLite, LevelDB, in-memory) live in consumer packages.
+ */
+export interface ProofGraphStoragePort {
+    save(graph: ProofGraph): Promise<void>;
+    load(graphId: string): Promise<ProofGraph | null>;
+    findByNodeId(id: string): Promise<ProofGraph | null>;
+}

package/dist/cjs/types.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * @totemsdk/proofgraph — Type definitions
+ *
+ * Pure schema — no network, no DHT, no blockchain submission, no crypto.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/verify.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Graph-level verification.
+ *
+ * verifyProofGraph: iterates proof nodes, recovers SignedProof from node.data,
+ * and delegates to @totemsdk/proof's verifyProof for each one.
+ * Never reimplements cryptography.
+ *
+ * verifyGraphProofs: same logic, returns the list of invalid proof IDs (string[]).
+ */
+import type { ProofGraph, ProofGraphVerifyResult } from './types.js';
+/**
+ * Verify every proof node stored in the graph.
+ *
+ * Iterates nodes of type 'proof', casts node.data back to SignedProof,
+ * and calls proofModule.verifyProof() from @totemsdk/proof.
+ * Returns { valid: true } if ALL proofs pass; otherwise lists the failing proofIds.
+ */
+export declare function verifyProofGraph(graph: ProofGraph, _options?: Record<string, unknown>): ProofGraphVerifyResult;
+/**
+ * Returns the list of invalid proof IDs in the graph.
+ * Equivalent to verifyProofGraph(graph).invalidProofs.
+ */
+export declare function verifyGraphProofs(graph: ProofGraph): string[];

package/dist/cjs/verify.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * Graph-level verification.
+ *
+ * verifyProofGraph: iterates proof nodes, recovers SignedProof from node.data,
+ * and delegates to @totemsdk/proof's verifyProof for each one.
+ * Never reimplements cryptography.
+ *
+ * verifyGraphProofs: same logic, returns the list of invalid proof IDs (string[]).
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyProofGraph = verifyProofGraph;
+exports.verifyGraphProofs = verifyGraphProofs;
+const proofModule = __importStar(require("@totemsdk/proof"));
+/**
+ * Verify every proof node stored in the graph.
+ *
+ * Iterates nodes of type 'proof', casts node.data back to SignedProof,
+ * and calls proofModule.verifyProof() from @totemsdk/proof.
+ * Returns { valid: true } if ALL proofs pass; otherwise lists the failing proofIds.
+ */
+function verifyProofGraph(graph, _options) {
+    const invalidProofs = [];
+    for (const node of graph.nodes) {
+        if (node.type !== 'proof' || !node.data)
+            continue;
+        const signedProof = node.data;
+        const result = proofModule.verifyProof(signedProof);
+        if (!result.valid) {
+            invalidProofs.push(node.refId);
+        }
+    }
+    return {
+        valid: invalidProofs.length === 0,
+        invalidProofs,
+    };
+}
+/**
+ * Returns the list of invalid proof IDs in the graph.
+ * Equivalent to verifyProofGraph(graph).invalidProofs.
+ */
+function verifyGraphProofs(graph) {
+    return verifyProofGraph(graph).invalidProofs;
+}

package/dist/durable-store.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Durable `ProofGraphStoragePort` adapter for @totemsdk/proofgraph.
+ *
+ * Implements RFC-007 G8 / §4.3: graph + reverse node index are persisted over a
+ * shared `StorageAdapter`, with restart recovery and concurrent-update safety
+ * (CAS guards on the head pointer and node index, serialized per adapter).
+ *
+ * Layout (single `StorageAdapter`, prefixed keys):
+ *   graph:<graphId>          { json, savedAt }   immutable content-addressed record
+ *   node:<nodeId>            { graphId, savedAt } reverse index (most-recent
+ *                           snapshot that contains the node)
+ *   head                     { graphId, savedAt } most-recent saved graph
+ *
+ * `load()` runs `importProofGraph`, which validates every node/edge and
+ * recomputes the graphId — a tampered or truncated record surfaces as
+ * `StorageError` `corrupt`, never as `not-found` (RFC-007 §4.2 strict).
+ */
+import type { StorageAdapter } from '@totemsdk/core';
+import type { WriteAckMode } from '@totemsdk/storage/types';
+import type { ProofGraph, ProofGraphStoragePort } from './types.js';
+export interface DurableProofGraphStoreOptions {
+    /** Key prefix (default 'totem_proofgraph:v1:'). */
+    namespace?: string;
+    /**
+     * Required write-ack level the backing adapter must satisfy (default
+     * 'durably-acknowledged').
+     */
+    requireAckMode?: WriteAckMode;
+}
+export interface ProofGraphRecoveryReport {
+    recoveredHead: boolean;
+    cleanedIndexKeys: number;
+}
+export type DurableProofGraphStore = ProofGraphStoragePort & {
+    /** Load the most-recent saved graph (the head). */
+    latest(): Promise<ProofGraph | null>;
+    /** List all persisted graphIds. */
+    listGraphIds(): Promise<string[]>;
+    /** Reconcile head + index after a crash/interruption. */
+    recover(): Promise<ProofGraphRecoveryReport>;
+};
+/**
+ * Create a durable `ProofGraphStoragePort` over a CAS-capable adapter.
+ *
+ * The head pointer and every reverse-index entry are guarded with the
+ * adapter's `conditionalUpdate`, and all mutations run serialized per adapter,
+ * so concurrent saves never clobber a newer graph. A non-CAS or low-durability
+ * adapter is rejected at construction (RFC-007 §4.2 no-silent-downgrade).
+ */
+export declare function createDurableProofGraphStore(adapter: StorageAdapter, options?: DurableProofGraphStoreOptions): DurableProofGraphStore;

package/dist/durable-store.js

@@ -0,0 +1,175 @@
+/**
+ * Durable `ProofGraphStoragePort` adapter for @totemsdk/proofgraph.
+ *
+ * Implements RFC-007 G8 / §4.3: graph + reverse node index are persisted over a
+ * shared `StorageAdapter`, with restart recovery and concurrent-update safety
+ * (CAS guards on the head pointer and node index, serialized per adapter).
+ *
+ * Layout (single `StorageAdapter`, prefixed keys):
+ *   graph:<graphId>          { json, savedAt }   immutable content-addressed record
+ *   node:<nodeId>            { graphId, savedAt } reverse index (most-recent
+ *                           snapshot that contains the node)
+ *   head                     { graphId, savedAt } most-recent saved graph
+ *
+ * `load()` runs `importProofGraph`, which validates every node/edge and
+ * recomputes the graphId — a tampered or truncated record surfaces as
+ * `StorageError` `corrupt`, never as `not-found` (RFC-007 §4.2 strict).
+ */
+import { assertCapabilities } from '@totemsdk/storage/types';
+import { StorageError } from '@totemsdk/storage/errors';
+import { exportProofGraph, importProofGraph } from './io.js';
+const DEFAULT_NAMESPACE = 'totem_proofgraph:v1:';
+const GRAPH_PREFIX = 'graph:';
+const NODE_PREFIX = 'node:';
+const HEAD_KEY = 'head';
+/** Per-adapter mutation lock so concurrent saves never interleave (wots-lease pattern). */
+const storageTails = new WeakMap();
+function withStorageLock(storage, fn) {
+    const previous = storageTails.get(storage) ?? Promise.resolve();
+    let release;
+    const gate = new Promise((resolve) => { release = resolve; });
+    storageTails.set(storage, previous.then(() => gate));
+    return previous.then(() => fn()).finally(release);
+}
+function isCasStore(adapter) {
+    return typeof adapter.conditionalUpdate === 'function';
+}
+/**
+ * Create a durable `ProofGraphStoragePort` over a CAS-capable adapter.
+ *
+ * The head pointer and every reverse-index entry are guarded with the
+ * adapter's `conditionalUpdate`, and all mutations run serialized per adapter,
+ * so concurrent saves never clobber a newer graph. A non-CAS or low-durability
+ * adapter is rejected at construction (RFC-007 §4.2 no-silent-downgrade).
+ */
+export function createDurableProofGraphStore(adapter, options = {}) {
+    const namespace = options.namespace ?? DEFAULT_NAMESPACE;
+    if (typeof adapter.capabilities === 'object') {
+        assertCapabilities(adapter, {
+            acknowledge: options.requireAckMode ?? 'durably-acknowledged',
+            atomic: true,
+            conditional: true,
+        });
+    }
+    if (!isCasStore(adapter)) {
+        throw new Error('createDurableProofGraphStore requires a CAS-capable storage adapter (CasStore.conditionalUpdate)');
+    }
+    const cas = adapter.conditionalUpdate.bind(adapter);
+    const graphKey = (graphId) => `${namespace}${GRAPH_PREFIX}${graphId}`;
+    const nodeKey = (nodeId) => `${namespace}${NODE_PREFIX}${nodeId}`;
+    const headKey = () => `${namespace}${HEAD_KEY}`;
+    /** Strictly-increasing savedAt so concurrent saves have deterministic order. */
+    let lastSavedAt = 0;
+    const nextSavedAt = () => {
+        const now = Date.now();
+        lastSavedAt = now > lastSavedAt ? now : lastSavedAt + 1;
+        return lastSavedAt;
+    };
+    function parseGraph(graphId, raw) {
+        if (typeof raw !== 'string' && (typeof raw !== 'object' || raw === null || typeof raw.json !== 'string')) {
+            throw new StorageError(`proofgraph record "${graphId}" is malformed`, 'corrupt', { key: graphKey(graphId) });
+        }
+        const json = typeof raw === 'string' ? raw : raw.json;
+        try {
+            return importProofGraph(json);
+        }
+        catch (err) {
+            throw new StorageError(`proofgraph record "${graphId}" failed validation: ${err.message}`, 'corrupt', { key: graphKey(graphId), cause: err });
+        }
+    }
+    async function loadUnchecked(graphId) {
+        const raw = await adapter.get(graphKey(graphId));
+        if (raw === null || raw === undefined)
+            return null;
+        return parseGraph(graphId, raw);
+    }
+    async function loadGraphForNode(nodeId) {
+        const entry = await adapter.get(nodeKey(nodeId));
+        if (entry === null || entry === undefined)
+            return null;
+        return loadUnchecked(entry.graphId);
+    }
+    async function writeIndexIfNewer(key, next) {
+        await cas(key, (current) => {
+            if (current && current.savedAt > next.savedAt)
+                return { abort: 'older snapshot' };
+            return { next };
+        });
+    }
+    return {
+        async save(graph) {
+            const savedAt = nextSavedAt();
+            return withStorageLock(adapter, async () => {
+                // Immutable content-addressed record first (idempotent, safe on retry).
+                const record = { json: exportProofGraph(graph), savedAt };
+                await adapter.set(graphKey(graph.graphId), record);
+                // Reverse index: most-recent snapshot wins (CAS, never clobbers newer).
+                for (const node of graph.nodes) {
+                    await writeIndexIfNewer(nodeKey(node.id), { graphId: graph.graphId, savedAt });
+                }
+                // Head pointer: does not move backwards.
+                await writeIndexIfNewer(headKey(), { graphId: graph.graphId, savedAt });
+            });
+        },
+        async load(graphId) {
+            return loadUnchecked(graphId);
+        },
+        async findByNodeId(id) {
+            return loadGraphForNode(id);
+        },
+        async latest() {
+            const head = await adapter.get(headKey());
+            if (head === null || head === undefined)
+                return null;
+            return loadUnchecked(head.graphId);
+        },
+        async listGraphIds() {
+            const prefix = `${namespace}${GRAPH_PREFIX}`;
+            const ids = [];
+            for (const key of await adapter.keys()) {
+                if (!key.startsWith(prefix))
+                    continue;
+                ids.push(key.slice(prefix.length));
+            }
+            return ids.sort();
+        },
+        async recover() {
+            return withStorageLock(adapter, async () => {
+                const report = { recoveredHead: false, cleanedIndexKeys: 0 };
+                const graphs = await this.listGraphIds();
+                const head = await adapter.get(headKey());
+                // 1. Head pointer: if absent but graphs exist, adopt the newest record.
+                if ((head === null || head === undefined) && graphs.length > 0) {
+                    let newest = null;
+                    for (const graphId of graphs) {
+                        const record = await adapter.get(graphKey(graphId));
+                        if (!record)
+                            continue;
+                        if (!newest || record.savedAt > newest.savedAt) {
+                            newest = { graphId, savedAt: record.savedAt };
+                        }
+                    }
+                    if (newest) {
+                        await writeIndexIfNewer(headKey(), newest);
+                        report.recoveredHead = true;
+                    }
+                }
+                // 2. Drop reverse-index entries pointing at absent graph records.
+                const nodePrefix = `${namespace}${NODE_PREFIX}`;
+                for (const key of await adapter.keys()) {
+                    if (!key.startsWith(nodePrefix))
+                        continue;
+                    const entry = await adapter.get(key);
+                    if (!entry)
+                        continue;
+                    const graphRecord = await adapter.get(graphKey(entry.graphId));
+                    if (graphRecord === null || graphRecord === undefined) {
+                        await adapter.remove(key);
+                        report.cleanedIndexKeys++;
+                    }
+                }
+                return report;
+            });
+        },
+    };
+}

package/dist/evidence.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Durable evidence-chain owner for @totemsdk/proofgraph (RFC-007 G8 / §4.3).
+ *
+ * Evidence *bytes* are owned by the minimal `ArtifactStore` over a pluggable
+ * backend; graph references alone do not satisfy the flight-evidence gate. This
+ * module wires a ProofGraph's `evidence` nodes to content-addressed artifacts,
+ * and restores the bytes on demand with commit-time digest verification.
+ *
+ * Restore semantics (RFC-007 §4.3): `corrupt` (bytes present but digest
+ * mismatch — tampered or truncated) is surfaced strictly, never collapsed into
+ * `not-found` (bytes absent); `unavailable` (backend unreachable, or the
+ * backend deleted a blob the local index still references) is also surfaced.
+ */
+import type { ProofGraph } from './types.js';
+import { ArtifactStore } from '@totemsdk/storage/artifacts';
+import type { ArtifactRef } from '@totemsdk/storage/artifacts';
+import type { StorageAdapter } from '@totemsdk/core';
+/**
+ * RFC-007 Amendment A (A3): the enforced binding between a claim's commitment
+ * and the artifact that addresses it.
+ *
+ * Invariant: `contentHash === artifact.digest`. `assertEvidenceBinding` throws
+ * `StorageError('corrupt')` when it does not hold, so an unrecoverable
+ * commitment cannot be constructed or restored.
+ */
+export interface EvidenceArtifactBinding {
+    readonly nodeId: string;
+    /** The commitment from the claim (hex, with or without `0x`). */
+    readonly contentHash: string;
+    /** The content-addressed artifact; `artifact.digest` must equal `contentHash`. */
+    readonly artifact: ArtifactRef;
+}
+export declare function normalizeEvidenceHash(hash: string): string;
+/** Throws `StorageError('corrupt')` unless `contentHash === artifact.digest`. */
+export declare function assertEvidenceBinding(binding: EvidenceArtifactBinding): void;
+export interface ProofGraphEvidenceStoreOptions {
+    /** Namespace the ArtifactStore writes artifact bytes under. */
+    namespace?: string;
+    /**
+     * true (default) — a `corrupt` or `unavailable` evidence read throws
+     * `StorageError` (never fail-open). `not-found` is always returned as a
+     * result, never thrown. Set false to return audit-able results instead.
+     */
+    strict?: boolean;
+}
+/** Per-evidence-node restore result. */
+export interface ProofGraphEvidenceResult {
+    nodeId: string;
+    status: 'ok' | 'not-found' | 'corrupt' | 'unavailable';
+    ref?: ArtifactRef;
+    /** The claim commitment this evidence is bound to, when known. */
+    contentHash?: string;
+    bytes?: Uint8Array;
+    message?: string;
+}
+export interface PutEvidenceOptions {
+    /**
+     * Explicit commitment per node. Falls back to the evidence node's
+     * `data.contentHash` (set by `addProof`). When a commitment is known, the
+     * stored bytes MUST hash to it and the artifact digest MUST equal it, or the
+     * put throws `StorageError('corrupt')`.
+     */
+    contentHashFor?: (nodeId: string) => string | undefined;
+    /**
+     * When true, every evidence node must have a commitment — a missing
+     * commitment throws. Default false (back-compat for nodes without one).
+     */
+    requireContentHash?: boolean;
+}
+export interface ProofGraphEvidenceStore {
+    /**
+     * Persist evidence bytes for every `evidence` node of `graph`.
+     * `bytesFor` maps a node id to the bytes to store; nodes with no bytes are
+     * skipped. When a commitment is known (node `data.contentHash` or
+     * `options.contentHashFor`), the claim→hash→artifact binding is enforced:
+     * `sha3_256(bytes) === contentHash === artifact.digest`.
+     * Returns the refs persisted, in graph node order.
+     */
+    putEvidence(graph: ProofGraph, bytesFor: (nodeId: string) => Uint8Array | undefined, options?: PutEvidenceOptions): Promise<ArtifactRef[]>;
+    /**
+     * Restore evidence bytes for every `evidence` node of `graph`, verifying
+     * each artifact's committed digest on read. With `strict` (default), corrupt
+     * or unavailable reads throw; otherwise a per-node result is returned.
+     */
+    restoreEvidence(graph: ProofGraph): Promise<ProofGraphEvidenceResult[]>;
+    /** Count of local index entries (persisted evidence mappings). */
+    listCount(): Promise<number>;
+}
+export declare function createProofGraphEvidenceStore(artifacts: ArtifactStore, index: StorageAdapter, options?: ProofGraphEvidenceStoreOptions): ProofGraphEvidenceStore;