@totemsdk/proofgraph 1.0.0 → 1.1.0

package/dist/cjs/index.js

@@ -0,0 +1,84 @@
+"use strict";
+/**
+ * @module @totemsdk/proofgraph
+ *
+ * Local deterministic proof relationship graph for Totem Edge.
+ *
+ * Indexes SignedProofs, SignedIdentityClaims, SignedManifests, identity
+ * documents, and custom evidence nodes into an immutable, queryable DAG
+ * keyed by a content-derived graphId. Pure package — no network, no DHT,
+ * no blockchain submission, no crypto reimplementation.
+ *
+ * Usage:
+ *   const g0 = createProofGraph();
+ *   const g1 = addProof(g0, signedProof);
+ *   const result = verifyProofGraph(g1);
+ */
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importProofGraph = exports.exportProofGraph = exports.verifyGraphProofs = exports.verifyProofGraph = exports.reachableFrom = exports.getEdgesBetween = exports.getManifestsForAddress = exports.getManifestRevisions = 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.addManifestRevision = 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 = exports.normalizeEvidenceHash = exports.assertEvidenceBinding = exports.createProofGraphEvidenceStore = exports.createDurableProofGraphStore = void 0;
+var durable_store_js_1 = require("./durable-store.js");
+Object.defineProperty(exports, "createDurableProofGraphStore", { enumerable: true, get: function () { return durable_store_js_1.createDurableProofGraphStore; } });
+var evidence_js_1 = require("./evidence.js");
+Object.defineProperty(exports, "createProofGraphEvidenceStore", { enumerable: true, get: function () { return evidence_js_1.createProofGraphEvidenceStore; } });
+Object.defineProperty(exports, "assertEvidenceBinding", { enumerable: true, get: function () { return evidence_js_1.assertEvidenceBinding; } });
+Object.defineProperty(exports, "normalizeEvidenceHash", { enumerable: true, get: function () { return evidence_js_1.normalizeEvidenceHash; } });
+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, "addManifestRevision", { enumerable: true, get: function () { return graph_js_1.addManifestRevision; } });
+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, "getManifestRevisions", { enumerable: true, get: function () { return query_js_1.getManifestRevisions; } });
+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; } });
+__exportStar(require("./replicated-evidence.js"), exports);

package/dist/cjs/io.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Serialization helpers for ProofGraph.
+ *
+ * exportProofGraph:  JSON-stringify the graph for storage or transport.
+ * importProofGraph:  parse JSON, validate every node/edge, recompute graphId,
+ *                    and throw if verification fails.
+ *
+ * The graphId guards against silent corruption in transit. Node/edge
+ * validation prevents hostile or malformed input from entering the system.
+ */
+import type { ProofGraph } from './types.js';
+/**
+ * Serialize a ProofGraph to a JSON string.
+ * The stored graphId was computed at mutation time and is included as-is.
+ */
+export declare function exportProofGraph(graph: ProofGraph): string;
+/**
+ * Deserialize a ProofGraph from a JSON string.
+ *
+ * Validates every node and edge against structural constraints, then
+ * recomputes the graphId from nodes + edges. Throws if any constraint
+ * is violated or if the recomputed graphId does not match the stored value.
+ *
+ * @throws Error if parsing, validation, or graphId verification fails.
+ */
+export declare function importProofGraph(json: string): ProofGraph;

package/dist/cjs/io.js

@@ -0,0 +1,173 @@
+"use strict";
+/**
+ * Serialization helpers for ProofGraph.
+ *
+ * exportProofGraph:  JSON-stringify the graph for storage or transport.
+ * importProofGraph:  parse JSON, validate every node/edge, recompute graphId,
+ *                    and throw if verification fails.
+ *
+ * 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");
+const VALID_NODE_TYPES = new Set([
+    'proof', 'identity', 'identity-claim', 'manifest', 'address',
+    'subject', 'evidence', 'anchor', 'receipt', 'payment', 'device',
+    'service', 'policy', 'custom',
+]);
+const VALID_EDGE_TYPES = new Set([
+    'proves', 'issued_by', 'signed_by', 'about', 'references',
+    'derived_from', 'supports', 'contradicts', 'supersedes', 'revokes',
+    'anchored_to', 'delegates_to', 'controls', 'depends_on',
+    'manifests_as', 'conflicts_with',
+]);
+const MAX_NODES = 10000;
+const MAX_EDGES = 50000;
+const MAX_STRING_LENGTH = 4096;
+const MAX_DATA_DEPTH = 10;
+const MAX_DATA_KEYS = 256;
+/**
+ * Validate a single ProofGraphNode.
+ * Throws if the node violates structural constraints.
+ */
+function validateNode(node, index) {
+    if (!node || typeof node !== 'object') {
+        throw new Error(`importProofGraph: nodes[${index}] is not an object`);
+    }
+    const n = node;
+    if (typeof n.id !== 'string' || n.id.length === 0) {
+        throw new Error(`importProofGraph: nodes[${index}] missing or empty id`);
+    }
+    if (typeof n.refId !== 'string' || n.refId.length === 0) {
+        throw new Error(`importProofGraph: nodes[${index}] missing or empty refId`);
+    }
+    if (n.id.length > MAX_STRING_LENGTH) {
+        throw new Error(`importProofGraph: nodes[${index}].id exceeds ${MAX_STRING_LENGTH} chars`);
+    }
+    if (n.refId.length > MAX_STRING_LENGTH) {
+        throw new Error(`importProofGraph: nodes[${index}].refId exceeds ${MAX_STRING_LENGTH} chars`);
+    }
+    if (!VALID_NODE_TYPES.has(String(n.type))) {
+        throw new Error(`importProofGraph: nodes[${index}] invalid type "${String(n.type)}"`);
+    }
+    if (typeof n.createdAt !== 'number' || n.createdAt < 0 || !Number.isFinite(n.createdAt)) {
+        throw new Error(`importProofGraph: nodes[${index}] invalid or negative createdAt`);
+    }
+    if (n.data !== undefined && n.data !== null) {
+        if (typeof n.data !== 'object') {
+            throw new Error(`importProofGraph: nodes[${index}].data must be an object`);
+        }
+        const keys = Object.keys(n.data);
+        if (keys.length > MAX_DATA_KEYS) {
+            throw new Error(`importProofGraph: nodes[${index}].data exceeds ${MAX_DATA_KEYS} keys`);
+        }
+        checkDepth(n.data, 0, MAX_DATA_DEPTH, `nodes[${index}].data`);
+    }
+}
+/**
+ * Validate a single ProofGraphEdge.
+ * Throws if the edge violates structural constraints.
+ */
+function validateEdge(edge, index) {
+    if (!edge || typeof edge !== 'object') {
+        throw new Error(`importProofGraph: edges[${index}] is not an object`);
+    }
+    const e = edge;
+    if (typeof e.id !== 'string' || e.id.length === 0) {
+        throw new Error(`importProofGraph: edges[${index}] missing or empty id`);
+    }
+    if (typeof e.from !== 'string' || e.from.length === 0) {
+        throw new Error(`importProofGraph: edges[${index}] missing or empty from`);
+    }
+    if (typeof e.to !== 'string' || e.to.length === 0) {
+        throw new Error(`importProofGraph: edges[${index}] missing or empty to`);
+    }
+    if (e.id.length > MAX_STRING_LENGTH || e.from.length > MAX_STRING_LENGTH || e.to.length > MAX_STRING_LENGTH) {
+        throw new Error(`importProofGraph: edges[${index}] string field exceeds ${MAX_STRING_LENGTH} chars`);
+    }
+    if (!VALID_EDGE_TYPES.has(String(e.type))) {
+        throw new Error(`importProofGraph: edges[${index}] invalid type "${String(e.type)}"`);
+    }
+    if (e.proofId !== undefined && typeof e.proofId !== 'string') {
+        throw new Error(`importProofGraph: edges[${index}].proofId must be a string`);
+    }
+    if (e.data !== undefined && e.data !== null) {
+        if (typeof e.data !== 'object') {
+            throw new Error(`importProofGraph: edges[${index}].data must be an object`);
+        }
+        checkDepth(e.data, 0, MAX_DATA_DEPTH, `edges[${index}].data`);
+    }
+}
+/**
+ * Recursive depth check on nested data objects to prevent deep-object attacks.
+ */
+function checkDepth(obj, depth, maxDepth, path) {
+    if (depth > maxDepth) {
+        throw new Error(`importProofGraph: ${path} exceeds max nesting depth of ${maxDepth}`);
+    }
+    for (const [key, value] of Object.entries(obj)) {
+        if (typeof key === 'string' && key.length > MAX_STRING_LENGTH) {
+            throw new Error(`importProofGraph: ${path} key exceeds ${MAX_STRING_LENGTH} chars`);
+        }
+        if (value !== null && typeof value === 'object' && !Array.isArray(value) && !(value instanceof Uint8Array)) {
+            checkDepth(value, depth + 1, maxDepth, `${path}.${key}`);
+        }
+    }
+}
+/**
+ * Serialize a ProofGraph to a JSON string.
+ * The stored graphId was computed at mutation time and is included as-is.
+ */
+function exportProofGraph(graph) {
+    return JSON.stringify(graph);
+}
+/**
+ * Deserialize a ProofGraph from a JSON string.
+ *
+ * Validates every node and edge against structural constraints, then
+ * recomputes the graphId from nodes + edges. Throws if any constraint
+ * is violated or if the recomputed graphId does not match the stored value.
+ *
+ * @throws Error if parsing, validation, or graphId verification fails.
+ */
+function importProofGraph(json) {
+    let parsed;
+    try {
+        parsed = JSON.parse(json);
+    }
+    catch (err) {
+        throw new Error(`importProofGraph: invalid JSON — ${err.message}`);
+    }
+    const graph = parsed;
+    if (!graph || typeof graph !== 'object') {
+        throw new Error('importProofGraph: parsed value is not an object');
+    }
+    if (!Array.isArray(graph.nodes) || !Array.isArray(graph.edges)) {
+        throw new Error('importProofGraph: missing nodes or edges arrays');
+    }
+    if (graph.nodes.length > MAX_NODES) {
+        throw new Error(`importProofGraph: node count ${graph.nodes.length} exceeds limit ${MAX_NODES}`);
+    }
+    if (graph.edges.length > MAX_EDGES) {
+        throw new Error(`importProofGraph: edge count ${graph.edges.length} exceeds limit ${MAX_EDGES}`);
+    }
+    // Validate every node and edge
+    for (let i = 0; i < graph.nodes.length; i++) {
+        validateNode(graph.nodes[i], i);
+    }
+    for (let i = 0; i < graph.edges.length; i++) {
+        validateEdge(graph.edges[i], i);
+    }
+    // Recompute and verify graphId
+    const originalId = typeof graph.graphId === 'string' ? graph.graphId : '';
+    const recomputed = (0, canonical_js_1.recomputeGraphId)(graph);
+    // If a stored graphId exists, verify it matches
+    if (originalId !== '' && recomputed !== originalId) {
+        throw new Error(`importProofGraph: graphId mismatch — stored="${originalId}" recomputed="${recomputed}"`);
+    }
+    // Return with graphId set to the recomputed value for consistency
+    return { ...graph, graphId: recomputed };
+}

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

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);
+}
+/**
+ * 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);
+}
+/**
+ * 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;