+ BNodeResolver: told-bnode emulation over the SPARQL protocol

SPARQL 1.0 rejected "told bnodes" (mentioning a blank node received in an
earlier response). Emulate them: for each SELECT, associate every response
bnode with a minimal, uniqueness-verified fragment of in/out arcs found by
instrumenting the query with interrogation round trips, recursing through
neighbor bnodes when ground arcs do not discriminate. Fragments intern to
stable proxy terms; mentioning a proxy in a later query expands to a fresh
variable constrained by its fragment. Ambiguous pins (N indistinguishable
candidates) resolve all candidates and assign response labels bijectively.

RemoteGraphProvider materializes triple-pattern fetches into a local BGP
with subsumption, so interrogation results answer later neighborhood
queries. Wired into ShEx validation (Validator::NeighborhoodSource) and
Algae 3 remote execution (Engine::remote fault-in at bgpmatch, attach via
Engine::attachClientFactory). RelabelingLocalClient test double relabels
response bnodes per response so label-luck code fails.

Deferred: bnodes emerging from grouped aggregates (the flagship query
never joins bnodes across an aggregation).

tests: proxy stability across relabeled responses; mention() rejoining
the right membership; cache subsumption; ShEx remote==local parity;
evidence-dnf remote==local golden.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: Eric Prud'hommeaux

CMakeLists.txt

@@ -168,6 +168,7 @@ add_library(SWObjects STATIC
   lib/ShExManifest.cpp
   lib/ShExMap.cpp
   lib/Algae3.cpp
+  lib/BNodeResolver.cpp
   lib/SWObjects.cpp
   ${SWOBJ_GENERATED_SOURCES}
 )

lib/Algae3.cpp

@@ -17,6 +17,7 @@
  */
 
 #include "Algae3.hpp"
+#include "BNodeResolver.hpp"
 #include "TurtleParser.hpp"
 
 #include <algorithm>
@@ -26,6 +27,8 @@
 namespace w3c_sw {
 namespace a3 {
 
+    bnr::SPARQLClient* (*Engine::attachClientFactory) (const std::string&, AtomFactory*) = NULL;
+
     const std::vector<const Result*>* Engine::currentGroup = NULL;
     const std::map<const Result*, ProofSet>* Engine::currentProofs = NULL;
     const RdfDB* Engine::currentDB = NULL;
@@ -89,7 +92,15 @@ namespace a3 {
 	rs = new ResultSet(atomFactory); // the unit result set
     }
 
-    Engine::~Engine () { delete rs; }
+    Engine::~Engine () {
+	delete rs;
+	for (std::vector<bnr::RemoteGraphProvider*>::const_iterator it = ownedProviders.begin();
+	     it != ownedProviders.end(); ++it)
+	    delete *it;
+	for (std::vector<bnr::SPARQLClient*>::const_iterator it = ownedClients.begin();
+	     it != ownedClients.end(); ++it)
+	    delete *it;
+    }
 
     ResultSet* Engine::unitRS () const { return new ResultSet(atomFactory); }
 
@@ -222,6 +233,8 @@ namespace a3 {
 	    const TTerm* s = lookup(tp->getS());
 	    const TTerm* p = lookup(tp->getP());
 	    const TTerm* o = lookup(tp->getO());
+	    if (e.remote != NULL)
+		e.remote->ensurePattern(s, p, o); // remote fault-in (told bnodes expand)
 	    const BasicGraphPattern::triple_iterator end;
 	    for (BasicGraphPattern::triple_iterator ti = graph->getTripleIterator(s, p, o);
 		 ti != end; ++ti) {
@@ -652,8 +665,16 @@ namespace a3 {
 	}
 
 	virtual void visit (const Attach& a) {
-	    throw std::string("attach (external database \"") + a.name
-		+ "\") is parsed for Algae2 compatibility but not evaluable here";
+	    if (Engine::attachClientFactory == NULL)
+		throw std::string("attach (external database \"") + a.name
+		    + "\"): no SPARQL client factory registered";
+	    bnr::SPARQLClient* client
+		= Engine::attachClientFactory(a.driver->getLexicalValue(), e.atomFactory);
+	    e.ownedClients.push_back(client);
+	    bnr::RemoteGraphProvider* provider = new bnr::RemoteGraphProvider(
+		e.atomFactory, client, e.db.ensureGraph(DefaultGraph));
+	    e.ownedProviders.push_back(provider);
+	    e.remote = provider;
 	}
 
 	virtual void visit (const Ask& a) { e.ask(*a.pattern); }

lib/Algae3.hpp

@@ -23,6 +23,7 @@
 #include <vector>
 
 namespace w3c_sw {
+namespace bnr { class RemoteGraphProvider; struct SPARQLClient; }
 namespace a3 {
 
     enum EvalMode { EVAL_topdown, EVAL_bottomup };
@@ -336,6 +337,17 @@ namespace a3 {
 	bool lastTest;           // set by `test`
 	std::string baseDir;     // directory for resolving load paths
 
+	/** remote execution: when set, bgpmatch faults each substituted
+	 * triple pattern through the provider (told-bnode seeds expand to
+	 * their identifying fragments) before matching the local cache */
+	bnr::RemoteGraphProvider* remote = NULL; // borrowed unless via attach
+	/** `attach <endpoint> name` creates a provider over a client from
+	 * this factory (tests inject a local relabeling double) */
+	static bnr::SPARQLClient* (*attachClientFactory) (const std::string& iri,
+							  AtomFactory* atomFactory);
+	std::vector<bnr::SPARQLClient*> ownedClients;        // from attach
+	std::vector<bnr::RemoteGraphProvider*> ownedProviders;
+
 	/** rows are sw::Results inside an sw::ResultSet (so sw::Expression
 	 * evaluation applies natively); proofs keyed by row pointer. */
 	ResultSet* rs;           // owned