@totemsdk/proofgraph 1.0.1 → 1.1.1

package/dist/cjs/query.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Query helpers for ProofGraph — pure read-only utilities.
+ *
+ * All functions receive a ProofGraph and return data without mutating the graph.
+ * Function names match the @totemsdk/proofgraph public API spec exactly.
+ */
+import type { ProofGraph, ProofGraphNode, ProofGraphEdge, ProofGraphEdgeType } from './types.js';
+/**
+ * Find a node by its composed node ID (type:refId) or by refId alone.
+ */
+export declare function findNode(graph: ProofGraph, id: string): ProofGraphNode | undefined;
+/**
+ * Return all outgoing edges from a node (identified by node ID or refId).
+ */
+export declare function getEdgesFrom(graph: ProofGraph, nodeIdOrRefId: string): ProofGraphEdge[];
+/**
+ * Return all incoming edges to a node (identified by node ID or refId).
+ */
+export declare function getEdgesTo(graph: ProofGraph, nodeIdOrRefId: string): ProofGraphEdge[];
+/**
+ * Return all edges of a given type.
+ */
+export declare function getEdgesByType(graph: ProofGraph, type: ProofGraphEdgeType): ProofGraphEdge[];
+/**
+ * Return all proof nodes in the graph.
+ */
+export declare function getProofNodes(graph: ProofGraph): ProofGraphNode[];
+/**
+ * Find all 'proof' nodes connected to a subject via 'about' OR 'proves' edges.
+ */
+export declare function findProofsBySubject(graph: ProofGraph, subjectId: string): ProofGraphNode[];
+/**
+ * Find all 'proof' nodes issued by a given address (via 'issued_by' edges).
+ */
+export declare function findProofsByIssuer(graph: ProofGraph, issuerId: string): ProofGraphNode[];
+/**
+ * Find all 'anchor' nodes linked to a proof via 'anchored_to' edges.
+ */
+export declare function findAnchorsForProof(graph: ProofGraph, proofId: string): ProofGraphNode[];
+/**
+ * Find all 'revokes' edges whose target is the given proof node.
+ */
+export declare function findRevocations(graph: ProofGraph, proofId: string): ProofGraphEdge[];
+/**
+ * Find all 'supersedes' edges whose target is the given proof node.
+ */
+export declare function findSupersessions(graph: ProofGraph, proofId: string): ProofGraphEdge[];
+/**
+ * Find all 'conflicts_with' edges involving the given proof node (in either direction).
+ */
+export declare function findConflicts(graph: ProofGraph, proofId: string): ProofGraphEdge[];
+/**
+ * Traverse 'references' edges from a proof to its evidence nodes.
+ * Returns nodes in insertion order (the order edges were added, which matches
+ * the original evidence array order from addProof).
+ */
+export declare function getEvidenceTrail(graph: ProofGraph, proofId: string): ProofGraphNode[];
+/**
+ * Recursively traverse 'derived_from' edges from a proof node.
+ * Returns the ordered chain of ancestor proof nodes (closest ancestor first).
+ * Terminates on cycle detection.
+ */
+export declare function getProofLineage(graph: ProofGraph, proofId: string, _visited?: Set<string>): ProofGraphNode[];
+/**
+ * Return all proof nodes that are NOT the target of any 'revokes' or 'supersedes' edge.
+ * These are the current / active proofs in the graph.
+ */
+export declare function resolveCurrentProofSet(graph: ProofGraph): ProofGraphNode[];
+/**
+ * Return all manifest nodes linked to a given address via 'manifests_as' edges.
+ */
+export declare function getManifestsForAddress(graph: ProofGraph, address: string): ProofGraphNode[];
+/**
+ * Return all content-addressed revisions of a logical manifest, ordered by envelope ID.
+ */
+export declare function getManifestRevisions(graph: ProofGraph, manifestId: string): ProofGraphNode[];
+/**
+ * Return all edges between two nodes (in either direction).
+ */
+export declare function getEdgesBetween(graph: ProofGraph, refIdA: string, refIdB: string): ProofGraphEdge[];
+/**
+ * Return the set of all node refIds reachable from a given node via directed edges.
+ * Includes the start node itself.
+ */
+export declare function reachableFrom(graph: ProofGraph, startRefId: string, _visited?: Set<string>): Set<string>;

package/dist/cjs/query.js

@@ -0,0 +1,189 @@
+"use strict";
+/**
+ * Query helpers for ProofGraph — pure read-only utilities.
+ *
+ * All functions receive a ProofGraph and return data without mutating the graph.
+ * Function names match the @totemsdk/proofgraph public API spec exactly.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findNode = findNode;
+exports.getEdgesFrom = getEdgesFrom;
+exports.getEdgesTo = getEdgesTo;
+exports.getEdgesByType = getEdgesByType;
+exports.getProofNodes = getProofNodes;
+exports.findProofsBySubject = findProofsBySubject;
+exports.findProofsByIssuer = findProofsByIssuer;
+exports.findAnchorsForProof = findAnchorsForProof;
+exports.findRevocations = findRevocations;
+exports.findSupersessions = findSupersessions;
+exports.findConflicts = findConflicts;
+exports.getEvidenceTrail = getEvidenceTrail;
+exports.getProofLineage = getProofLineage;
+exports.resolveCurrentProofSet = resolveCurrentProofSet;
+exports.getManifestsForAddress = getManifestsForAddress;
+exports.getManifestRevisions = getManifestRevisions;
+exports.getEdgesBetween = getEdgesBetween;
+exports.reachableFrom = reachableFrom;
+/**
+ * Find a node by its composed node ID (type:refId) or by refId alone.
+ */
+function findNode(graph, id) {
+    return graph.nodes.find((n) => n.id === id || n.refId === id);
+}
+/**
+ * Return all outgoing edges from a node (identified by node ID or refId).
+ */
+function getEdgesFrom(graph, nodeIdOrRefId) {
+    const node = findNode(graph, nodeIdOrRefId);
+    if (!node)
+        return [];
+    return graph.edges.filter((e) => e.from === node.refId || e.from === node.id);
+}
+/**
+ * Return all incoming edges to a node (identified by node ID or refId).
+ */
+function getEdgesTo(graph, nodeIdOrRefId) {
+    const node = findNode(graph, nodeIdOrRefId);
+    if (!node)
+        return [];
+    return graph.edges.filter((e) => e.to === node.refId || e.to === node.id);
+}
+/**
+ * Return all edges of a given type.
+ */
+function getEdgesByType(graph, type) {
+    return graph.edges.filter((e) => e.type === type);
+}
+/**
+ * Return all proof nodes in the graph.
+ */
+function getProofNodes(graph) {
+    return graph.nodes.filter((n) => n.type === 'proof');
+}
+/**
+ * Find all 'proof' nodes connected to a subject via 'about' OR 'proves' edges.
+ */
+function findProofsBySubject(graph, subjectId) {
+    const relevantEdges = graph.edges.filter((e) => (e.type === 'about' || e.type === 'proves') && e.to === subjectId);
+    const proofRefIds = new Set(relevantEdges.map((e) => e.from));
+    return graph.nodes.filter((n) => proofRefIds.has(n.refId) && n.type === 'proof');
+}
+/**
+ * Find all 'proof' nodes issued by a given address (via 'issued_by' edges).
+ */
+function findProofsByIssuer(graph, issuerId) {
+    const issuedEdges = graph.edges.filter((e) => e.type === 'issued_by' && e.to === issuerId);
+    const proofRefIds = new Set(issuedEdges.map((e) => e.from));
+    return graph.nodes.filter((n) => proofRefIds.has(n.refId) && n.type === 'proof');
+}
+/**
+ * Find all 'anchor' nodes linked to a proof via 'anchored_to' edges.
+ */
+function findAnchorsForProof(graph, proofId) {
+    const anchoredEdges = graph.edges.filter((e) => e.type === 'anchored_to' && e.from === proofId);
+    const anchorRefIds = new Set(anchoredEdges.map((e) => e.to));
+    return graph.nodes.filter((n) => anchorRefIds.has(n.refId) && n.type === 'anchor');
+}
+/**
+ * Find all 'revokes' edges whose target is the given proof node.
+ */
+function findRevocations(graph, proofId) {
+    return graph.edges.filter((e) => e.type === 'revokes' && e.to === proofId);
+}
+/**
+ * Find all 'supersedes' edges whose target is the given proof node.
+ */
+function findSupersessions(graph, proofId) {
+    return graph.edges.filter((e) => e.type === 'supersedes' && e.to === proofId);
+}
+/**
+ * Find all 'conflicts_with' edges involving the given proof node (in either direction).
+ */
+function findConflicts(graph, proofId) {
+    return graph.edges.filter((e) => e.type === 'conflicts_with' &&
+        (e.from === proofId || e.to === proofId));
+}
+/**
+ * Traverse 'references' edges from a proof to its evidence nodes.
+ * Returns nodes in insertion order (the order edges were added, which matches
+ * the original evidence array order from addProof).
+ */
+function getEvidenceTrail(graph, proofId) {
+    const refEdges = graph.edges.filter((e) => e.type === 'references' && e.from === proofId);
+    return refEdges
+        .map((e) => graph.nodes.find((n) => n.refId === e.to && n.type === 'evidence'))
+        .filter((n) => n !== undefined);
+}
+/**
+ * Recursively traverse 'derived_from' edges from a proof node.
+ * Returns the ordered chain of ancestor proof nodes (closest ancestor first).
+ * Terminates on cycle detection.
+ */
+function getProofLineage(graph, proofId, _visited = new Set()) {
+    if (_visited.has(proofId))
+        return [];
+    _visited.add(proofId);
+    const derivedEdges = graph.edges.filter((e) => e.type === 'derived_from' && e.from === proofId);
+    const result = [];
+    for (const edge of derivedEdges) {
+        const node = graph.nodes.find((n) => n.refId === edge.to);
+        if (node) {
+            result.push(node);
+            result.push(...getProofLineage(graph, edge.to, _visited));
+        }
+    }
+    return result;
+}
+/**
+ * Return all proof nodes that are NOT the target of any 'revokes' or 'supersedes' edge.
+ * These are the current / active proofs in the graph.
+ */
+function resolveCurrentProofSet(graph) {
+    const supersededOrRevoked = new Set();
+    for (const edge of graph.edges) {
+        if (edge.type === 'revokes' || edge.type === 'supersedes') {
+            supersededOrRevoked.add(edge.to);
+        }
+    }
+    return graph.nodes.filter((n) => n.type === 'proof' && !supersededOrRevoked.has(n.refId));
+}
+/**
+ * Return all manifest nodes linked to a given address via 'manifests_as' edges.
+ */
+function getManifestsForAddress(graph, address) {
+    const manifestEdges = graph.edges.filter((e) => e.type === 'manifests_as' && e.to === address);
+    const manifestRefIds = new Set(manifestEdges.map((e) => e.from));
+    return graph.nodes.filter((n) => manifestRefIds.has(n.refId) && n.type === 'manifest');
+}
+/**
+ * Return all content-addressed revisions of a logical manifest, ordered by envelope ID.
+ */
+function getManifestRevisions(graph, manifestId) {
+    const revisionRefs = new Set(graph.edges
+        .filter((edge) => edge.type === 'revision_of' && edge.to === manifestId)
+        .map((edge) => edge.from));
+    return graph.nodes
+        .filter((node) => node.type === 'manifest' && revisionRefs.has(node.refId))
+        .sort((a, b) => a.refId.localeCompare(b.refId));
+}
+/**
+ * Return all edges between two nodes (in either direction).
+ */
+function getEdgesBetween(graph, refIdA, refIdB) {
+    return graph.edges.filter((e) => (e.from === refIdA && e.to === refIdB) ||
+        (e.from === refIdB && e.to === refIdA));
+}
+/**
+ * Return the set of all node refIds reachable from a given node via directed edges.
+ * Includes the start node itself.
+ */
+function reachableFrom(graph, startRefId, _visited = new Set()) {
+    if (_visited.has(startRefId))
+        return _visited;
+    _visited.add(startRefId);
+    const outgoing = graph.edges.filter((e) => e.from === startRefId);
+    for (const edge of outgoing) {
+        reachableFrom(graph, edge.to, _visited);
+    }
+    return _visited;
+}

package/dist/cjs/replicated-evidence.d.ts

@@ -0,0 +1,42 @@
+/**
+ * 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.
+ */
+import type { ArtifactRef, ArtifactStore } from '@totemsdk/storage/artifacts';
+import type { ProofGraph } from './types.js';
+export interface ReplicatedEvidenceIndexEntry {
+    readonly nodeId: string;
+    readonly ref: ArtifactRef;
+    readonly contentHash: string;
+    readonly storedAt: number;
+}
+export interface ReplicatedEvidenceIndexPort {
+    get(key: string): Promise<unknown | null>;
+    put(key: string, value: unknown): Promise<void>;
+    list?(prefix?: string): AsyncIterable<{
+        key: string;
+        value: unknown;
+    }>;
+}
+export interface ReplicatedEvidenceRead {
+    readonly nodeId: string;
+    readonly status: 'ok' | 'not-found' | 'corrupt' | 'unavailable';
+    readonly ref?: ArtifactRef;
+    readonly bytes?: Uint8Array;
+    readonly message?: string;
+}
+export interface ReplicatedProofGraphEvidenceStore {
+    putEvidence(graph: ProofGraph, bytesFor: (nodeId: string) => Uint8Array | undefined): Promise<ArtifactRef[]>;
+    getEvidence(nodeId: string): Promise<ReplicatedEvidenceRead>;
+    verifyEvidence(nodeId: string): Promise<boolean>;
+    listEvidence(): AsyncIterable<ReplicatedEvidenceIndexEntry>;
+}
+export declare function createReplicatedProofGraphEvidenceStore(options: {
+    artifacts: ArtifactStore;
+    index: ReplicatedEvidenceIndexPort;
+    namespace?: string;
+}): ReplicatedProofGraphEvidenceStore;

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.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Durable `ProofGraphStoragePort` adapter for @totemsdk/proofgraph.
  *
@@ -16,11 +15,9 @@
  * recomputes the graphId — a tampered or truncated record surfaces as
  * `StorageError` `corrupt`, never as `not-found` (RFC-007 §4.2 strict).
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDurableProofGraphStore = createDurableProofGraphStore;
-const types_1 = require("@totemsdk/storage/types");
-const errors_1 = require("@totemsdk/storage/errors");
-const io_js_1 = require("./io.js");
+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:';
@@ -45,10 +42,10 @@ function isCasStore(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).
  */
-function createDurableProofGraphStore(adapter, options = {}) {
+export function createDurableProofGraphStore(adapter, options = {}) {
     const namespace = options.namespace ?? DEFAULT_NAMESPACE;
     if (typeof adapter.capabilities === 'object') {
-        (0, types_1.assertCapabilities)(adapter, {
+        assertCapabilities(adapter, {
             acknowledge: options.requireAckMode ?? 'durably-acknowledged',
             atomic: true,
             conditional: true,
@@ -70,14 +67,14 @@ function createDurableProofGraphStore(adapter, options = {}) {
     };
     function parseGraph(graphId, raw) {
         if (typeof raw !== 'string' && (typeof raw !== 'object' || raw === null || typeof raw.json !== 'string')) {
-            throw new errors_1.StorageError(`proofgraph record "${graphId}" is malformed`, 'corrupt', { key: graphKey(graphId) });
+            throw new StorageError(`proofgraph record "${graphId}" is malformed`, 'corrupt', { key: graphKey(graphId) });
         }
         const json = typeof raw === 'string' ? raw : raw.json;
         try {
-            return (0, io_js_1.importProofGraph)(json);
+            return importProofGraph(json);
         }
         catch (err) {
-            throw new errors_1.StorageError(`proofgraph record "${graphId}" failed validation: ${err.message}`, 'corrupt', { key: graphKey(graphId), cause: err });
+            throw new StorageError(`proofgraph record "${graphId}" failed validation: ${err.message}`, 'corrupt', { key: graphKey(graphId), cause: err });
         }
     }
     async function loadUnchecked(graphId) {
@@ -104,7 +101,7 @@ function createDurableProofGraphStore(adapter, options = {}) {
             const savedAt = nextSavedAt();
             return withStorageLock(adapter, async () => {
                 // Immutable content-addressed record first (idempotent, safe on retry).
-                const record = { json: (0, io_js_1.exportProofGraph)(graph), savedAt };
+                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) {