@totemsdk/proofgraph 1.0.0 → 1.1.0

package/dist/evidence.js

@@ -0,0 +1,125 @@
+/**
+ * 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 { StorageError } from '@totemsdk/storage/errors';
+import { sha3_256, toHex } from '@totemsdk/core';
+const DEFAULT_NS = 'totem-proofgraph-evidence';
+const INDEX_PREFIX = 'totem_proofgraph_evidence:v1:';
+export function normalizeEvidenceHash(hash) {
+    return hash.replace(/^0x/i, '').toLowerCase();
+}
+/** Throws `StorageError('corrupt')` unless `contentHash === artifact.digest`. */
+export function assertEvidenceBinding(binding) {
+    if (normalizeEvidenceHash(binding.contentHash) !== normalizeEvidenceHash(binding.artifact.digest)) {
+        throw new StorageError(`evidence binding mismatch for node "${binding.nodeId}": contentHash ${binding.contentHash} !== artifact.digest ${binding.artifact.digest}`, 'corrupt', { key: binding.nodeId });
+    }
+}
+function evidenceNodeIds(graph) {
+    return graph.nodes.filter((node) => node.type === 'evidence').map((node) => node.id);
+}
+/** The claim commitment carried on an evidence node (`data.contentHash`). */
+function nodeContentHash(graph, nodeId) {
+    const value = graph.nodes.find((node) => node.id === nodeId)?.data?.contentHash;
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+export function createProofGraphEvidenceStore(artifacts, index, options = {}) {
+    if (!artifacts.capabilities.writable) {
+        throw new Error('createProofGraphEvidenceStore requires a writable artifact store');
+    }
+    const namespace = options.namespace ?? DEFAULT_NS;
+    const strict = options.strict ?? true;
+    const indexKey = (nodeId) => `${INDEX_PREFIX}${nodeId}`;
+    return {
+        async putEvidence(graph, bytesFor, options = {}) {
+            const refs = [];
+            for (const nodeId of evidenceNodeIds(graph)) {
+                const bytes = bytesFor(nodeId);
+                if (!bytes)
+                    continue;
+                const contentHash = options.contentHashFor?.(nodeId) ?? nodeContentHash(graph, nodeId);
+                if (!contentHash && options.requireContentHash) {
+                    throw new StorageError(`evidence commitment missing for node "${nodeId}"`, 'corrupt', { key: indexKey(nodeId) });
+                }
+                // Byte-identity invariant: the stored bytes must hash to the commitment.
+                const digest = toHex(sha3_256(bytes));
+                if (contentHash && normalizeEvidenceHash(contentHash) !== digest) {
+                    throw new StorageError(`evidence commitment mismatch for node "${nodeId}": sha3(bytes) ${digest} !== contentHash ${contentHash}`, 'corrupt', { key: indexKey(nodeId) });
+                }
+                const receipt = await artifacts.put(namespace, bytes).catch((err) => {
+                    throw new StorageError(`evidence put failed for node "${nodeId}": ${err.message}`, 'write-failed', { key: indexKey(nodeId), cause: err });
+                });
+                if (contentHash) {
+                    // The artifact must address exactly the committed hash.
+                    assertEvidenceBinding({ nodeId, contentHash, artifact: receipt.ref });
+                }
+                const entry = {
+                    ref: receipt.ref,
+                    ...(contentHash ? { contentHash: normalizeEvidenceHash(contentHash) } : {}),
+                };
+                await index.set(indexKey(nodeId), entry);
+                refs.push(receipt.ref);
+            }
+            return refs;
+        },
+        async restoreEvidence(graph) {
+            const results = [];
+            const fail = (err) => {
+                if (err instanceof StorageError)
+                    throw err;
+                throw new StorageError(`evidence read failed: ${err.message}`, 'unavailable', { cause: err });
+            };
+            for (const nodeId of evidenceNodeIds(graph)) {
+                const entry = await index.get(indexKey(nodeId));
+                if (!entry) {
+                    results.push({ nodeId, status: 'not-found', message: 'no evidence artifact persisted for node' });
+                    continue;
+                }
+                const { ref, contentHash } = entry;
+                if (contentHash) {
+                    // Index-tamper guard: the enforced binding must still hold.
+                    assertEvidenceBinding({ nodeId, contentHash, artifact: ref });
+                }
+                const read = await artifacts.get(ref).catch(fail);
+                switch (read.status) {
+                    case 'ok':
+                        results.push({ nodeId, status: 'ok', ref, ...(contentHash ? { contentHash } : {}), bytes: read.bytes });
+                        break;
+                    case 'corrupt':
+                        if (strict) {
+                            throw new StorageError(`evidence artifact corrupt for node "${nodeId}": ${read.message ?? 'digest mismatch'}`, 'corrupt', { key: indexKey(nodeId) });
+                        }
+                        results.push({ nodeId, status: 'corrupt', ref, message: read.message ?? 'digest mismatch' });
+                        break;
+                    case 'unavailable':
+                        if (strict) {
+                            throw new StorageError(`evidence artifact unavailable for node "${nodeId}": ${read.message ?? 'backend unavailable'}`, 'unavailable', { key: indexKey(nodeId) });
+                        }
+                        results.push({ nodeId, status: 'unavailable', ref, message: read.message ?? 'backend unavailable' });
+                        break;
+                    case 'not-found':
+                        results.push({ nodeId, status: 'not-found', ref, message: read.message ?? 'evidence artifact not found' });
+                        break;
+                }
+            }
+            return results;
+        },
+        async listCount() {
+            let count = 0;
+            for (const key of await index.keys()) {
+                if (key.startsWith(INDEX_PREFIX))
+                    count++;
+            }
+            return count;
+        },
+    };
+}

package/dist/graph.d.ts

@@ -80,6 +80,17 @@ export declare function addIdentityClaim(graph: ProofGraph, signedClaim: SignedI
  *   manifests_as  manifest → address
  */
 export declare function addManifest(graph: ProofGraph, signedManifest: SignedManifest): ProofGraph;
+/**
+ * Add a signed manifest **revision** without collapsing other revisions.
+ *
+ * Creates:
+ *   manifest (logical)   refId = manifestId
+ *   manifest (revision)  refId = manifestEnvelopeId, data = { manifestId, manifestEnvelopeId, signedManifest }
+ *   address              resolved author/operator address
+ *   manifests_as         manifestId → address
+ *   revision_of          manifestEnvelopeId → manifestId
+ */
+export declare function addManifestRevision(graph: ProofGraph, signedManifest: SignedManifest): ProofGraph;
 /**
  * Add a receipt-like node (payment, subscription, claim receipt) to the graph.
  * If receipt.proofId is set, adds a 'supports' edge from the receipt to that proof.

package/dist/graph.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Proof graph mutation functions — all pure, all returning NEW graphs.
  *
@@ -6,23 +5,12 @@
  * recomputed graphId. Nodes and edges are deduplicated by ID so adding the
  * same proof twice is idempotent.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createProofGraph = createProofGraph;
-exports.setGraphMetadata = setGraphMetadata;
-exports.buildEdge = buildEdge;
-exports.addNode = addNode;
-exports.addEdge = addEdge;
-exports.addIdentityDocument = addIdentityDocument;
-exports.addProof = addProof;
-exports.addIdentityClaim = addIdentityClaim;
-exports.addManifest = addManifest;
-exports.addReceiptLike = addReceiptLike;
-exports.addAnchor = addAnchor;
-const manifest_1 = require("@totemsdk/manifest");
-const canonical_js_1 = require("./canonical.js");
+import { computeManifestId, computeManifestEnvelopeId } from '@totemsdk/manifest';
+import { computeNodeId, computeEdgeId, computeProofGraphId } from './canonical.js';
+import { normalizeEvidenceHash } from './evidence.js';
 function makeNode(type, refId, data) {
     return {
-        id: (0, canonical_js_1.computeNodeId)(type, refId),
+        id: computeNodeId(type, refId),
         type,
         refId,
         ...(data !== undefined ? { data } : {}),
@@ -31,7 +19,7 @@ function makeNode(type, refId, data) {
 }
 function makeEdge(type, from, to, proofId, data) {
     return {
-        id: (0, canonical_js_1.computeEdgeId)(type, from, to, proofId, data),
+        id: computeEdgeId(type, from, to, proofId, data),
         type,
         from,
         to,
@@ -64,17 +52,17 @@ function rebuild(graph, newNodes, newEdges) {
         ...graph,
         nodes,
         edges,
-        graphId: (0, canonical_js_1.computeProofGraphId)(nodes, edges),
+        graphId: computeProofGraphId(nodes, edges),
     };
 }
 /**
  * Create an empty ProofGraph.
  */
-function createProofGraph(metadata) {
+export function createProofGraph(metadata) {
     const nodes = [];
     const edges = [];
     return {
-        graphId: (0, canonical_js_1.computeProofGraphId)(nodes, edges),
+        graphId: computeProofGraphId(nodes, edges),
         nodes,
         edges,
         createdAt: Date.now(),
@@ -84,39 +72,39 @@ function createProofGraph(metadata) {
 /**
  * Attach or replace mutable metadata. Does NOT affect graphId.
  */
-function setGraphMetadata(graph, metadata) {
+export function setGraphMetadata(graph, metadata) {
     return { ...graph, metadata };
 }
 /**
  * Build a ProofGraphEdge with a deterministic ID from its fields.
  * Convenience helper so callers don't need to import computeEdgeId.
  */
-function buildEdge(type, from, to, proofId, data) {
+export function buildEdge(type, from, to, proofId, data) {
     return makeEdge(type, from, to, proofId, data);
 }
 /**
  * Add a node directly (type + refId pair). Idempotent — skipped if the node already exists.
  */
-function addNode(graph, type, refId, data) {
+export function addNode(graph, type, refId, data) {
     return rebuild(graph, [makeNode(type, refId, data)], []);
 }
 /**
  * Append a ProofGraphEdge and recompute graphId. Idempotent by edge ID.
  * Spec API: addEdge(graph, edge). Use buildEdge() to construct the edge object.
  */
-function addEdge(graph, edge) {
+export function addEdge(graph, edge) {
     const edges = mergeEdges(graph.edges, [edge]);
     return {
         ...graph,
         edges,
-        graphId: (0, canonical_js_1.computeProofGraphId)(graph.nodes, edges),
+        graphId: computeProofGraphId(graph.nodes, edges),
     };
 }
 /**
  * Index a TotemIdentityDocument into the graph.
  * Creates an 'identity' node with refId = doc.id.
  */
-function addIdentityDocument(graph, doc) {
+export function addIdentityDocument(graph, doc) {
     return rebuild(graph, [makeNode('identity', doc.id, { ...doc })], []);
 }
 /**
@@ -136,7 +124,7 @@ function addIdentityDocument(graph, doc) {
  *   references  proof → evidence (one per evidence ref, in array order)
  *   anchored_to proof → anchor (if present)
  */
-function addProof(graph, signedProof) {
+export function addProof(graph, signedProof) {
     const proofNode = makeNode('proof', signedProof.proofId, {
         ...signedProof,
     });
@@ -150,7 +138,9 @@ function addProof(graph, signedProof) {
     ];
     if (signedProof.evidence) {
         for (const ev of signedProof.evidence) {
-            newNodes.push(makeNode('evidence', ev.id));
+            // RFC-007 Amendment A (A3): carry the claim commitment on the evidence
+            // node so the evidence store can enforce claim→contentHash→artifact.
+            newNodes.push(makeNode('evidence', ev.id, ev.hash ? { contentHash: normalizeEvidenceHash(ev.hash) } : undefined));
             newEdges.push(makeEdge('references', signedProof.proofId, ev.id, signedProof.proofId));
         }
     }
@@ -174,7 +164,7 @@ function addProof(graph, signedProof) {
  *   revokes      → revokes edge      (claim-node → subject identity)
  *   rotates_to   → controls edge     (claim-node → new address)
  */
-function addIdentityClaim(graph, signedClaim) {
+export function addIdentityClaim(graph, signedClaim) {
     const { claim } = signedClaim;
     const claimNode = makeNode('identity-claim', claim.id, {
         ...signedClaim,
@@ -228,8 +218,8 @@ function resolveManifestAddress(signedManifest) {
  * Edge created:
  *   manifests_as  manifest → address
  */
-function addManifest(graph, signedManifest) {
-    const manifestId = (0, manifest_1.computeManifestId)(signedManifest.manifest);
+export function addManifest(graph, signedManifest) {
+    const manifestId = computeManifestId(signedManifest.manifest);
     const address = resolveManifestAddress(signedManifest);
     const manifestNode = makeNode('manifest', manifestId, {
         ...signedManifest,
@@ -239,11 +229,37 @@ function addManifest(graph, signedManifest) {
         makeEdge('manifests_as', manifestId, address),
     ]);
 }
+/**
+ * Add a signed manifest **revision** without collapsing other revisions.
+ *
+ * Creates:
+ *   manifest (logical)   refId = manifestId
+ *   manifest (revision)  refId = manifestEnvelopeId, data = { manifestId, manifestEnvelopeId, signedManifest }
+ *   address              resolved author/operator address
+ *   manifests_as         manifestId → address
+ *   revision_of          manifestEnvelopeId → manifestId
+ */
+export function addManifestRevision(graph, signedManifest) {
+    const manifestId = computeManifestId(signedManifest.manifest);
+    const manifestEnvelopeId = computeManifestEnvelopeId(signedManifest);
+    const address = resolveManifestAddress(signedManifest);
+    const logicalNode = makeNode('manifest', manifestId, { manifestId });
+    const revisionNode = makeNode('manifest', manifestEnvelopeId, {
+        manifestId,
+        manifestEnvelopeId,
+        signedManifest,
+    });
+    const addressNode = makeNode('address', address);
+    return rebuild(graph, [logicalNode, revisionNode, addressNode], [
+        makeEdge('manifests_as', manifestId, address),
+        makeEdge('revision_of', manifestEnvelopeId, manifestId),
+    ]);
+}
 /**
  * Add a receipt-like node (payment, subscription, claim receipt) to the graph.
  * If receipt.proofId is set, adds a 'supports' edge from the receipt to that proof.
  */
-function addReceiptLike(graph, receipt) {
+export function addReceiptLike(graph, receipt) {
     const { id, data, proofId } = receipt;
     const receiptNode = makeNode('receipt', id, data);
     const newEdges = [];
@@ -256,7 +272,7 @@ function addReceiptLike(graph, receipt) {
  * Add a standalone anchor node. If anchor.proofId is set, adds an 'anchored_to'
  * edge from the proof to this anchor.
  */
-function addAnchor(graph, anchor) {
+export function addAnchor(graph, anchor) {
     const { hash, proofId, ...rest } = anchor;
     const nodeData = { ...rest };
     const anchorNode = makeNode('anchor', hash, Object.keys(nodeData).length > 0 ? nodeData : undefined);

package/dist/index.d.ts

@@ -14,8 +14,13 @@
  *   const result = verifyProofGraph(g1);
  */
 export type { ProofGraphNodeType, ProofGraphEdgeType, ProofGraphNode, ProofGraphEdge, ProofGraph, ProofGraphVerifyResult, ProofGraphStoragePort, ReceiptLikeInput, AnchorInput, } from './types.js';
+export { createDurableProofGraphStore, } from './durable-store.js';
+export type { DurableProofGraphStore, DurableProofGraphStoreOptions, ProofGraphRecoveryReport, } from './durable-store.js';
+export { createProofGraphEvidenceStore, assertEvidenceBinding, normalizeEvidenceHash, } from './evidence.js';
+export type { ProofGraphEvidenceStore, ProofGraphEvidenceStoreOptions, ProofGraphEvidenceResult, EvidenceArtifactBinding, PutEvidenceOptions, } from './evidence.js';
 export { toHex, canonicalJson, computeNodeId, computeEdgeId, computeProofGraphId, recomputeGraphId, } from './canonical.js';
-export { createProofGraph, setGraphMetadata, buildEdge, addNode, addEdge, addIdentityDocument, addProof, addIdentityClaim, addManifest, addReceiptLike, addAnchor, } from './graph.js';
-export { findNode, getEdgesFrom, getEdgesTo, getEdgesByType, getProofNodes, findProofsBySubject, findProofsByIssuer, findAnchorsForProof, findRevocations, findSupersessions, findConflicts, getEvidenceTrail, getProofLineage, resolveCurrentProofSet, getManifestsForAddress, getEdgesBetween, reachableFrom, } from './query.js';
+export { createProofGraph, setGraphMetadata, buildEdge, addNode, addEdge, addIdentityDocument, addProof, addIdentityClaim, addManifest, addManifestRevision, addReceiptLike, addAnchor, } from './graph.js';
+export { findNode, getEdgesFrom, getEdgesTo, getEdgesByType, getProofNodes, findProofsBySubject, findProofsByIssuer, findAnchorsForProof, findRevocations, findSupersessions, findConflicts, getEvidenceTrail, getProofLineage, resolveCurrentProofSet, getManifestRevisions, getManifestsForAddress, getEdgesBetween, reachableFrom, } from './query.js';
 export { verifyProofGraph, verifyGraphProofs, } from './verify.js';
 export { exportProofGraph, importProofGraph, } from './io.js';
+export * from './replicated-evidence.js';

package/dist/index.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * @module @totemsdk/proofgraph
  *
@@ -14,48 +13,11 @@
  *   const g1 = addProof(g0, signedProof);
  *   const result = verifyProofGraph(g1);
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.importProofGraph = exports.exportProofGraph = exports.verifyGraphProofs = exports.verifyProofGraph = exports.reachableFrom = exports.getEdgesBetween = exports.getManifestsForAddress = exports.resolveCurrentProofSet = exports.getProofLineage = exports.getEvidenceTrail = exports.findConflicts = exports.findSupersessions = exports.findRevocations = exports.findAnchorsForProof = exports.findProofsByIssuer = exports.findProofsBySubject = exports.getProofNodes = exports.getEdgesByType = exports.getEdgesTo = exports.getEdgesFrom = exports.findNode = exports.addAnchor = exports.addReceiptLike = exports.addManifest = exports.addIdentityClaim = exports.addProof = exports.addIdentityDocument = exports.addEdge = exports.addNode = exports.buildEdge = exports.setGraphMetadata = exports.createProofGraph = exports.recomputeGraphId = exports.computeProofGraphId = exports.computeEdgeId = exports.computeNodeId = exports.canonicalJson = exports.toHex = void 0;
-var canonical_js_1 = require("./canonical.js"); // canonicalJson / toHex re-exported from @totemsdk/proof
-Object.defineProperty(exports, "toHex", { enumerable: true, get: function () { return canonical_js_1.toHex; } });
-Object.defineProperty(exports, "canonicalJson", { enumerable: true, get: function () { return canonical_js_1.canonicalJson; } });
-Object.defineProperty(exports, "computeNodeId", { enumerable: true, get: function () { return canonical_js_1.computeNodeId; } });
-Object.defineProperty(exports, "computeEdgeId", { enumerable: true, get: function () { return canonical_js_1.computeEdgeId; } });
-Object.defineProperty(exports, "computeProofGraphId", { enumerable: true, get: function () { return canonical_js_1.computeProofGraphId; } });
-Object.defineProperty(exports, "recomputeGraphId", { enumerable: true, get: function () { return canonical_js_1.recomputeGraphId; } });
-var graph_js_1 = require("./graph.js");
-Object.defineProperty(exports, "createProofGraph", { enumerable: true, get: function () { return graph_js_1.createProofGraph; } });
-Object.defineProperty(exports, "setGraphMetadata", { enumerable: true, get: function () { return graph_js_1.setGraphMetadata; } });
-Object.defineProperty(exports, "buildEdge", { enumerable: true, get: function () { return graph_js_1.buildEdge; } });
-Object.defineProperty(exports, "addNode", { enumerable: true, get: function () { return graph_js_1.addNode; } });
-Object.defineProperty(exports, "addEdge", { enumerable: true, get: function () { return graph_js_1.addEdge; } });
-Object.defineProperty(exports, "addIdentityDocument", { enumerable: true, get: function () { return graph_js_1.addIdentityDocument; } });
-Object.defineProperty(exports, "addProof", { enumerable: true, get: function () { return graph_js_1.addProof; } });
-Object.defineProperty(exports, "addIdentityClaim", { enumerable: true, get: function () { return graph_js_1.addIdentityClaim; } });
-Object.defineProperty(exports, "addManifest", { enumerable: true, get: function () { return graph_js_1.addManifest; } });
-Object.defineProperty(exports, "addReceiptLike", { enumerable: true, get: function () { return graph_js_1.addReceiptLike; } });
-Object.defineProperty(exports, "addAnchor", { enumerable: true, get: function () { return graph_js_1.addAnchor; } });
-var query_js_1 = require("./query.js");
-Object.defineProperty(exports, "findNode", { enumerable: true, get: function () { return query_js_1.findNode; } });
-Object.defineProperty(exports, "getEdgesFrom", { enumerable: true, get: function () { return query_js_1.getEdgesFrom; } });
-Object.defineProperty(exports, "getEdgesTo", { enumerable: true, get: function () { return query_js_1.getEdgesTo; } });
-Object.defineProperty(exports, "getEdgesByType", { enumerable: true, get: function () { return query_js_1.getEdgesByType; } });
-Object.defineProperty(exports, "getProofNodes", { enumerable: true, get: function () { return query_js_1.getProofNodes; } });
-Object.defineProperty(exports, "findProofsBySubject", { enumerable: true, get: function () { return query_js_1.findProofsBySubject; } });
-Object.defineProperty(exports, "findProofsByIssuer", { enumerable: true, get: function () { return query_js_1.findProofsByIssuer; } });
-Object.defineProperty(exports, "findAnchorsForProof", { enumerable: true, get: function () { return query_js_1.findAnchorsForProof; } });
-Object.defineProperty(exports, "findRevocations", { enumerable: true, get: function () { return query_js_1.findRevocations; } });
-Object.defineProperty(exports, "findSupersessions", { enumerable: true, get: function () { return query_js_1.findSupersessions; } });
-Object.defineProperty(exports, "findConflicts", { enumerable: true, get: function () { return query_js_1.findConflicts; } });
-Object.defineProperty(exports, "getEvidenceTrail", { enumerable: true, get: function () { return query_js_1.getEvidenceTrail; } });
-Object.defineProperty(exports, "getProofLineage", { enumerable: true, get: function () { return query_js_1.getProofLineage; } });
-Object.defineProperty(exports, "resolveCurrentProofSet", { enumerable: true, get: function () { return query_js_1.resolveCurrentProofSet; } });
-Object.defineProperty(exports, "getManifestsForAddress", { enumerable: true, get: function () { return query_js_1.getManifestsForAddress; } });
-Object.defineProperty(exports, "getEdgesBetween", { enumerable: true, get: function () { return query_js_1.getEdgesBetween; } });
-Object.defineProperty(exports, "reachableFrom", { enumerable: true, get: function () { return query_js_1.reachableFrom; } });
-var verify_js_1 = require("./verify.js");
-Object.defineProperty(exports, "verifyProofGraph", { enumerable: true, get: function () { return verify_js_1.verifyProofGraph; } });
-Object.defineProperty(exports, "verifyGraphProofs", { enumerable: true, get: function () { return verify_js_1.verifyGraphProofs; } });
-var io_js_1 = require("./io.js");
-Object.defineProperty(exports, "exportProofGraph", { enumerable: true, get: function () { return io_js_1.exportProofGraph; } });
-Object.defineProperty(exports, "importProofGraph", { enumerable: true, get: function () { return io_js_1.importProofGraph; } });
+export { createDurableProofGraphStore, } from './durable-store.js';
+export { createProofGraphEvidenceStore, assertEvidenceBinding, normalizeEvidenceHash, } from './evidence.js';
+export { toHex, canonicalJson, computeNodeId, computeEdgeId, computeProofGraphId, recomputeGraphId, } from './canonical.js'; // canonicalJson / toHex re-exported from @totemsdk/proof
+export { createProofGraph, setGraphMetadata, buildEdge, addNode, addEdge, addIdentityDocument, addProof, addIdentityClaim, addManifest, addManifestRevision, addReceiptLike, addAnchor, } from './graph.js';
+export { findNode, getEdgesFrom, getEdgesTo, getEdgesByType, getProofNodes, findProofsBySubject, findProofsByIssuer, findAnchorsForProof, findRevocations, findSupersessions, findConflicts, getEvidenceTrail, getProofLineage, resolveCurrentProofSet, getManifestRevisions, getManifestsForAddress, getEdgesBetween, reachableFrom, } from './query.js';
+export { verifyProofGraph, verifyGraphProofs, } from './verify.js';
+export { exportProofGraph, importProofGraph, } from './io.js';
+export * from './replicated-evidence.js';

package/dist/io.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Serialization helpers for ProofGraph.
  *
@@ -9,10 +8,7 @@
  * The graphId guards against silent corruption in transit. Node/edge
  * validation prevents hostile or malformed input from entering the system.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.exportProofGraph = exportProofGraph;
-exports.importProofGraph = importProofGraph;
-const canonical_js_1 = require("./canonical.js");
+import { recomputeGraphId } from './canonical.js';
 const VALID_NODE_TYPES = new Set([
     'proof', 'identity', 'identity-claim', 'manifest', 'address',
     'subject', 'evidence', 'anchor', 'receipt', 'payment', 'device',
@@ -121,7 +117,7 @@ function checkDepth(obj, depth, maxDepth, path) {
  * Serialize a ProofGraph to a JSON string.
  * The stored graphId was computed at mutation time and is included as-is.
  */
-function exportProofGraph(graph) {
+export function exportProofGraph(graph) {
     return JSON.stringify(graph);
 }
 /**
@@ -133,7 +129,7 @@ function exportProofGraph(graph) {
  *
  * @throws Error if parsing, validation, or graphId verification fails.
  */
-function importProofGraph(json) {
+export function importProofGraph(json) {
     let parsed;
     try {
         parsed = JSON.parse(json);
@@ -163,7 +159,7 @@ function importProofGraph(json) {
     }
     // Recompute and verify graphId
     const originalId = typeof graph.graphId === 'string' ? graph.graphId : '';
-    const recomputed = (0, canonical_js_1.recomputeGraphId)(graph);
+    const recomputed = recomputeGraphId(graph);
     // If a stored graphId exists, verify it matches
     if (originalId !== '' && recomputed !== originalId) {
         throw new Error(`importProofGraph: graphId mismatch — stored="${originalId}" recomputed="${recomputed}"`);

package/dist/query.d.ts

@@ -70,6 +70,10 @@ export declare function resolveCurrentProofSet(graph: ProofGraph): ProofGraphNod
  * 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).
  */

package/dist/query.js

@@ -1,38 +1,19 @@
-"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.getEdgesBetween = getEdgesBetween;
-exports.reachableFrom = reachableFrom;
 /**
  * Find a node by its composed node ID (type:refId) or by refId alone.
  */
-function findNode(graph, id) {
+export 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) {
+export function getEdgesFrom(graph, nodeIdOrRefId) {
     const node = findNode(graph, nodeIdOrRefId);
     if (!node)
         return [];
@@ -41,7 +22,7 @@ function getEdgesFrom(graph, nodeIdOrRefId) {
 /**
  * Return all incoming edges to a node (identified by node ID or refId).
  */
-function getEdgesTo(graph, nodeIdOrRefId) {
+export function getEdgesTo(graph, nodeIdOrRefId) {
     const node = findNode(graph, nodeIdOrRefId);
     if (!node)
         return [];
@@ -50,19 +31,19 @@ function getEdgesTo(graph, nodeIdOrRefId) {
 /**
  * Return all edges of a given type.
  */
-function getEdgesByType(graph, type) {
+export function getEdgesByType(graph, type) {
     return graph.edges.filter((e) => e.type === type);
 }
 /**
  * Return all proof nodes in the graph.
  */
-function getProofNodes(graph) {
+export 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) {
+export 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');
@@ -70,7 +51,7 @@ function findProofsBySubject(graph, subjectId) {
 /**
  * Find all 'proof' nodes issued by a given address (via 'issued_by' edges).
  */
-function findProofsByIssuer(graph, issuerId) {
+export 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');
@@ -78,7 +59,7 @@ function findProofsByIssuer(graph, issuerId) {
 /**
  * Find all 'anchor' nodes linked to a proof via 'anchored_to' edges.
  */
-function findAnchorsForProof(graph, proofId) {
+export 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');
@@ -86,19 +67,19 @@ function findAnchorsForProof(graph, proofId) {
 /**
  * Find all 'revokes' edges whose target is the given proof node.
  */
-function findRevocations(graph, proofId) {
+export 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) {
+export 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) {
+export function findConflicts(graph, proofId) {
     return graph.edges.filter((e) => e.type === 'conflicts_with' &&
         (e.from === proofId || e.to === proofId));
 }
@@ -107,7 +88,7 @@ function findConflicts(graph, proofId) {
  * Returns nodes in insertion order (the order edges were added, which matches
  * the original evidence array order from addProof).
  */
-function getEvidenceTrail(graph, proofId) {
+export 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'))
@@ -118,7 +99,7 @@ function getEvidenceTrail(graph, proofId) {
  * Returns the ordered chain of ancestor proof nodes (closest ancestor first).
  * Terminates on cycle detection.
  */
-function getProofLineage(graph, proofId, _visited = new Set()) {
+export function getProofLineage(graph, proofId, _visited = new Set()) {
     if (_visited.has(proofId))
         return [];
     _visited.add(proofId);
@@ -137,7 +118,7 @@ function getProofLineage(graph, proofId, _visited = new Set()) {
  * 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) {
+export function resolveCurrentProofSet(graph) {
     const supersededOrRevoked = new Set();
     for (const edge of graph.edges) {
         if (edge.type === 'revokes' || edge.type === 'supersedes') {
@@ -149,15 +130,26 @@ function resolveCurrentProofSet(graph) {
 /**
  * Return all manifest nodes linked to a given address via 'manifests_as' edges.
  */
-function getManifestsForAddress(graph, address) {
+export 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.
+ */
+export 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) {
+export function getEdgesBetween(graph, refIdA, refIdB) {
     return graph.edges.filter((e) => (e.from === refIdA && e.to === refIdB) ||
         (e.from === refIdB && e.to === refIdA));
 }
@@ -165,7 +157,7 @@ function getEdgesBetween(graph, refIdA, refIdB) {
  * 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()) {
+export function reachableFrom(graph, startRefId, _visited = new Set()) {
     if (_visited.has(startRefId))
         return _visited;
     _visited.add(startRefId);