graphwise-reactodia 0.0.1-TR9 → 0.0.1-blank-nodes-TR2

package/dist/cjs/graphwise-reactodia.cjs.entry.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var index$1 = require('./index-CII9aUQC.js');
+var index$1 = require('./index-D1-Nmh_N.js');
 var index = require('./index.cjs.js');
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
@@ -776,7 +776,7 @@ var global$1 = (typeof global !== "undefined" ? global :
   typeof self !== "undefined" ? self :
   typeof window !== "undefined" ? window : {});
 
-var lookup = [];
+var lookup$1 = [];
 var revLookup = [];
 var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array;
 var inited = false;
@@ -784,7 +784,7 @@ function init () {
   inited = true;
   var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
   for (var i = 0, len = code.length; i < len; ++i) {
-    lookup[i] = code[i];
+    lookup$1[i] = code[i];
     revLookup[code.charCodeAt(i)] = i;
   }
 
@@ -838,7 +838,7 @@ function toByteArray (b64) {
 }
 
 function tripletToBase64 (num) {
-  return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F]
+  return lookup$1[num >> 18 & 0x3F] + lookup$1[num >> 12 & 0x3F] + lookup$1[num >> 6 & 0x3F] + lookup$1[num & 0x3F]
 }
 
 function encodeChunk (uint8, start, end) {
@@ -870,14 +870,14 @@ function fromByteArray (uint8) {
   // pad the end with zeros, but make sure to not forget the extra bytes
   if (extraBytes === 1) {
     tmp = uint8[len - 1];
-    output += lookup[tmp >> 2];
-    output += lookup[(tmp << 4) & 0x3F];
+    output += lookup$1[tmp >> 2];
+    output += lookup$1[(tmp << 4) & 0x3F];
     output += '==';
   } else if (extraBytes === 2) {
     tmp = (uint8[len - 2] << 8) + (uint8[len - 1]);
-    output += lookup[tmp >> 10];
-    output += lookup[(tmp >> 4) & 0x3F];
-    output += lookup[(tmp << 2) & 0x3F];
+    output += lookup$1[tmp >> 10];
+    output += lookup$1[(tmp >> 4) & 0x3F];
+    output += lookup$1[(tmp << 2) & 0x3F];
     output += '=';
   }
 
@@ -6400,6 +6400,567 @@ function escapeRegexp(token) {
 	return token.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
 }
 //#endregion
+//#region src/data/sparql/sparqlModels.ts
+function mapSparqlResponseIntoRdfJs(response, factory) {
+	function mapSparqlBinding(binding) {
+		const mapped = {};
+		for (const key in binding) if (Object.prototype.hasOwnProperty.call(binding, key)) {
+			const term = binding[key];
+			switch (term.type) {
+				case "uri":
+					mapped[key] = factory.namedNode(term.value);
+					break;
+				case "bnode":
+					mapped[key] = factory.blankNode(term.value);
+					break;
+				case "literal":
+				case "typed-literal":
+					mapped[key] = factory.literal(term.value, term["xml:lang"] ? term["xml:lang"] : term.datatype ? factory.namedNode(term.datatype) : void 0);
+					break;
+				default: throw new Error(`Unexpected SPARQL term type: "${term.type}"`);
+			}
+		}
+		return mapped;
+	}
+	return {
+		...response,
+		results: {
+			...response.results,
+			bindings: response.results.bindings.map(mapSparqlBinding)
+		}
+	};
+}
+function isRdfIri(term) {
+	return Boolean(term && term.termType === "NamedNode");
+}
+function isRdfBlank(term) {
+	return Boolean(term && term.termType === "BlankNode");
+}
+function isRdfLiteral(term) {
+	return Boolean(term && term.termType === "Literal");
+}
+function isBlankBinding(binding) {
+	const blank = binding;
+	return blank.blankTrgProp !== void 0 || blank.blankTrg !== void 0 || blank.blankSrcProp !== void 0 || blank.blankSrc !== void 0;
+}
+/**
+* IRI prefix for the encoded blank node subtype produced by this module.
+*
+* @see {@link isEncodedBlank}
+*/
+var ENCODED_PREFIX = "urn:reactodia:blank:sparql:";
+/**
+* There is no way to refer to an existing blank node from a SPARQL query, and the labels
+* an endpoint returns for one are local to the response they came in. Instead of trying to
+* address a blank node, the whole statement set which describes it is encoded into the
+* element IRI, which makes the identity content-addressed: the same surrounding graph always
+* yields the same IRI, and every request about such an element can be answered locally by
+* decoding it back, without another round-trip to the endpoint.
+*
+* The trade-off is size: the IRI grows linearly with the number of statements attached to
+* the blank node, at roughly 300 characters per statement. {@link MAX_RECURSION_DEEP} bounds
+* how deep nesting can go, but nothing bounds how wide a single blank node can be, so a long
+* RDF list produces a correspondingly long IRI (measured against the W3C Organization
+* ontology: 380-1650 characters for its OWL axioms; a synthetic 100-member list: ~28 KB).
+*/
+function isEncodedBlank$1(iri) {
+	return iri.startsWith(ENCODED_PREFIX);
+}
+/**
+* Additional output bindings which {@link BLANK_NODE_QUERY} produces, to be added
+* to the outer projection of the lookup query.
+*/
+var BLANK_NODE_QUERY_PARAMETERS = "?blankType ?blankTrgProp ?blankTrg ?blankSrc ?blankSrcProp";
+/**
+* Lookup query addition which describes every blank node in `?inst` by its outgoing
+* statements and the statement pointing at it.
+*
+* The three alternatives handle a plain blank node, an RDF list referenced directly
+* and a cell in the middle of an RDF list (which is resolved to the list head, so that
+* a list appears as a single element rather than one element per cell).
+*/
+var BLANK_NODE_QUERY = `
+    OPTIONAL {
+        FILTER (ISBLANK(?inst)).
+        {
+            ?inst ?blankTrgProp ?blankTrg.
+            ?blankSrc ?blankSrcProp ?inst.
+            FILTER NOT EXISTS { ?inst rdf:first _:smth1 }.
+            BIND("blankNode" as ?blankType)
+        } UNION {
+            ?inst rdf:rest*/rdf:first ?blankTrg.
+            ?blankSrc ?blankSrcProp ?inst.
+            _:smth2 rdf:first ?blankTrg.
+            BIND(?blankSrcProp as ?blankTrgProp)
+            BIND("listHead" as ?blankType)
+            FILTER NOT EXISTS { _:smth3 rdf:rest ?inst }.
+        } UNION {
+            ?listHead rdf:rest* ?inst.
+            FILTER NOT EXISTS { _:smth4 rdf:rest ?listHead }.
+
+            ?listHead rdf:rest*/rdf:first ?blankTrg.
+            ?blankSrc ?blankSrcProp ?listHead.
+            _:smth5 rdf:first ?blankTrg.
+            BIND(?blankSrcProp as ?blankTrgProp)
+            BIND("listHead" as ?blankType)
+        }
+    }
+`;
+var XSD_STRING = "http://www.w3.org/2001/XMLSchema#string";
+function encodeTerm(term) {
+	switch (term.termType) {
+		case "NamedNode": return ["i", term.value];
+		case "BlankNode": return ["b", term.value];
+		case "Literal":
+			if (term.language) return [
+				"l",
+				term.value,
+				term.language
+			];
+			else if (term.datatype && term.datatype.value !== XSD_STRING) return [
+				"d",
+				term.value,
+				term.datatype.value
+			];
+			return ["l", term.value];
+	}
+}
+function decodeTerm(encoded, factory) {
+	switch (encoded[0]) {
+		case "i": return factory.namedNode(encoded[1]);
+		case "b": return factory.blankNode(encoded[1]);
+		case "l": return factory.literal(encoded[1], encoded[2]);
+		case "d": return factory.literal(encoded[1], factory.namedNode(encoded[2]));
+		default: throw new Error(`Unexpected encoded blank node term: ${JSON.stringify(encoded)}`);
+	}
+}
+/**
+* Encodes the statement set which describes a single blank node into an element IRI.
+*
+* Bindings are deduplicated and sorted, so that the same statement set always produces
+* the same IRI regardless of the order the endpoint returned it in. The blank node label
+* itself is deliberately left out: it is local to the response it came from and would make
+* the IRI change between otherwise identical requests.
+*/
+function encodeId(blankBindings, statementLimit) {
+	const bindingSet = /* @__PURE__ */ new Map();
+	for (const binding of blankBindings) {
+		const encoded = {
+			t: binding.blankType.value,
+			p: encodeTerm(binding.blankTrgProp),
+			o: encodeTerm(binding.blankTrg),
+			s: binding.blankSrc ? encodeTerm(binding.blankSrc) : void 0,
+			sp: binding.blankSrcProp ? encodeTerm(binding.blankSrcProp) : void 0,
+			c: binding.class ? encodeTerm(binding.class) : void 0
+		};
+		bindingSet.set(JSON.stringify(encoded), encoded);
+	}
+	const orderedKeys = Array.from(bindingSet.keys()).sort();
+	const normalizedBindings = (typeof statementLimit === "number" ? orderedKeys.slice(0, Math.max(statementLimit, 0)) : orderedKeys).map((key) => bindingSet.get(key));
+	return ENCODED_PREFIX + toBase64Url(JSON.stringify(normalizedBindings));
+}
+/**
+* Encodes the payload as base64url rather than percent-escaping it.
+*
+* A nested blank node is embedded into its parent by its own encoded IRI, and base64url
+* output contains only characters which need no escaping, so nesting costs a flat 4/3 per
+* level. Percent-escaping would escape the escapes, roughly doubling the payload at every
+* level instead.
+*/
+function toBase64Url(text) {
+	const bytes = new TextEncoder().encode(text);
+	let binary = "";
+	for (const byte of bytes) binary += String.fromCharCode(byte);
+	return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function fromBase64Url(encoded) {
+	const binary = atob(encoded.replace(/-/g, "+").replace(/_/g, "/"));
+	const bytes = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+	return new TextDecoder().decode(bytes);
+}
+/**
+* Decodes an element IRI produced by {@link encodeId} back into the statement set it
+* was made from, or returns `undefined` if the IRI is not an encoded blank node or
+* cannot be parsed.
+*/
+function decodeId(id, factory) {
+	if (!isEncodedBlank$1(id)) return;
+	let parsed;
+	try {
+		const encodedPart = id.substring(27);
+		parsed = JSON.parse(fromBase64Url(encodedPart));
+		if (!Array.isArray(parsed)) return;
+	} catch {
+		return;
+	}
+	try {
+		const inst = factory.namedNode(id);
+		return parsed.map((encoded) => {
+			const binding = {
+				inst,
+				blankType: factory.literal(encoded.t),
+				blankTrgProp: decodeTerm(encoded.p, factory),
+				blankTrg: decodeTerm(encoded.o, factory),
+				blankSrc: encoded.s ? decodeTerm(encoded.s, factory) : void 0,
+				blankSrcProp: encoded.sp ? decodeTerm(encoded.sp, factory) : void 0,
+				class: encoded.c ? decodeTerm(encoded.c, factory) : void 0
+			};
+			binding.label = createLabelForBlankBinding(binding, factory);
+			return binding;
+		});
+	} catch {
+		return;
+	}
+}
+function createLabelForBlankBinding(binding, factory) {
+	if (binding.blankType.value === "listHead") return factory.literal("RDFList");
+	const { class: classTerm } = binding;
+	return factory.literal(classTerm ? getLocalName(classTerm.value) ?? classTerm.value : "anonymous");
+}
+/**
+* Deduplicates identical in-flight queries, since the chains being followed
+* often overlap on their leading statements.
+*/
+var QueryExecutor = class {
+	queryFunction;
+	running = /* @__PURE__ */ new Map();
+	constructor(queryFunction) {
+		this.queryFunction = queryFunction;
+	}
+	executeQuery(query) {
+		const existing = this.running.get(query);
+		if (existing) return existing;
+		const execution = this.queryFunction(query).then((response) => {
+			this.running.delete(query);
+			return response;
+		}, (error) => {
+			this.running.delete(query);
+			throw error;
+		});
+		this.running.set(query, execution);
+		return execution;
+	}
+};
+/**
+* Replaces the raw blank node bindings in a lookup response with bindings whose `inst`
+* is an encoded IRI, resolving nested blank nodes along the way.
+*/
+async function updateLookupResults(result, queryFunction, settings, factory) {
+	const completeBindings = [];
+	const blankBindings = [];
+	for (const binding of result.results.bindings) if (isBlankBinding(binding)) blankBindings.push(binding);
+	else completeBindings.push(binding);
+	if (blankBindings.length === 0) return result;
+	const processedBindings = await processBlankBindings(blankBindings, queryFunction, settings, factory);
+	return {
+		...result,
+		results: {
+			...result.results,
+			bindings: completeBindings.concat(processedBindings)
+		}
+	};
+}
+/**
+* Groups raw blank node bindings by the blank node they describe, resolves any nested
+* blank nodes they point at and rewrites both the instance and the nested targets into
+* encoded IRIs.
+*
+* The bindings are mutated in place and returned.
+*/
+async function processBlankBindings(blankBindings, queryFunction, settings, factory) {
+	const bindingGroupsById = /* @__PURE__ */ new Map();
+	for (const binding of blankBindings) {
+		let group = bindingGroupsById.get(binding.inst.value);
+		if (!group) {
+			group = [];
+			bindingGroupsById.set(binding.inst.value, group);
+		}
+		group.push(binding);
+	}
+	const nestedChains = [];
+	for (const binding of blankBindings) if (isRdfBlank(binding.blankTrg)) nestedChains.push([binding]);
+	const loadedGroups = await loadRelatedBlankNodes(nestedChains, new QueryExecutor(queryFunction), settings, factory);
+	const { blankNodeStatementLimit } = settings;
+	const idsMap = getEncodedIdDictionary(loadedGroups, factory, blankNodeStatementLimit);
+	for (const group of bindingGroupsById.values()) {
+		for (const binding of group) {
+			const encodedNestedId = idsMap.get(binding.blankTrg.value);
+			if (encodedNestedId !== void 0) binding.blankTrg = factory.namedNode(encodedNestedId);
+			if (!binding.label) binding.label = createLabelForBlankBinding(binding, factory);
+		}
+		updateGroupIds(group, encodeId(group, blankNodeStatementLimit), factory);
+	}
+	return blankBindings.slice();
+}
+function getEncodedIdDictionary(blankBindingGroups, factory, statementLimit) {
+	const idDictionary = /* @__PURE__ */ new Map();
+	for (const [key, group] of blankBindingGroups) {
+		const encodedId = encodeId(group, statementLimit);
+		idDictionary.set(key, encodedId);
+		updateGroupIds(group, encodedId, factory);
+	}
+	return idDictionary;
+}
+function updateGroupIds(group, newId, factory) {
+	const inst = factory.namedNode(newId);
+	for (const binding of group) binding.inst = inst;
+}
+async function loadRelatedBlankNodes(blankChains, queryExecutor, settings, factory, recursionDeep = 1) {
+	const loadedBlankBindings = /* @__PURE__ */ new Map();
+	if (recursionDeep > 3 || blankChains.length === 0) return loadedBlankBindings;
+	const results = await Promise.all(blankChains.map(async (chain) => ({
+		chain,
+		response: await queryExecutor.executeQuery(getQueryForChain(chain, settings))
+	})));
+	await Promise.all(results.map(async ({ chain, response }) => {
+		const bindings = response.results.bindings;
+		if (bindings.length === 0) return;
+		const nestedChains = [];
+		for (const binding of bindings) if (isRdfBlank(binding.blankTrg)) nestedChains.push(chain.concat([binding]));
+		const idsMap = getEncodedIdDictionary(await loadRelatedBlankNodes(nestedChains, queryExecutor, settings, factory, recursionDeep + 1), factory, settings.blankNodeStatementLimit);
+		for (const binding of bindings) {
+			const encodedNestedId = idsMap.get(binding.blankTrg.value);
+			if (encodedNestedId !== void 0) binding.blankTrg = factory.namedNode(encodedNestedId);
+			binding.label = createLabelForBlankBinding(binding, factory);
+			let group = loadedBlankBindings.get(binding.inst.value);
+			if (!group) {
+				group = [];
+				loadedBlankBindings.set(binding.inst.value, group);
+			}
+			group.push(binding);
+		}
+	}));
+	return loadedBlankBindings;
+}
+/**
+* Builds a query which walks the chain of statements from the named node the chain starts at
+* down to the blank node at its end, and describes that blank node.
+*
+* The chain is expressed entirely in IRIs and predicates, since blank node labels from
+* a previous response cannot be used to address anything in a new query.
+*/
+function getQueryForChain(blankNodes, settings) {
+	function getQueryBlock(blankNode, index, maxIndex) {
+		const trustableTrgProp = index === 0 || blankNode.blankType.value !== "listHead";
+		const sourceId = index > 0 ? `?inst${index - 1}` : formatChainTerm(blankNode.blankSrc, `?blankAnySrc${index}`);
+		const sourcePropId = trustableTrgProp ? index > 0 ? `?blankTrgProp${index - 1}` : formatChainTerm(blankNode.blankSrcProp, `?blankAnySrcProp${index}`) : `?anyType${index}`;
+		const instPostfix = index === maxIndex ? "" : index.toString();
+		const targetPropId = trustableTrgProp ? formatChainTerm(blankNode.blankTrgProp, `?blankAnyTrgProp${index}`) : `?anyType0${index}`;
+		return `
+            # ======================
+            ${sourceId} ${sourcePropId} ?blankSrc${index}.
+            ${index === 0 && blankNode.blankType.value === "listHead" ? `?blankSrc${index} rdf:rest*/rdf:first ?inst${instPostfix}.` : `?blankSrc${index} ${targetPropId} ?inst${instPostfix}.`}
+            BIND (${formatChainTerm(blankNode.blankTrgProp, `?blankAnyBind${index}`)} as ?blankSrcProp${index}).
+            FILTER (ISBLANK(?inst${instPostfix})).
+            {
+                ?inst${instPostfix} ?blankTrgProp${instPostfix} ?blankTrg${instPostfix}.
+                BIND("blankNode" as ?blankType${instPostfix}).
+                FILTER NOT EXISTS { ?inst${instPostfix} rdf:first _:smth1${index} }.
+            } UNION {
+                ?inst${instPostfix} rdf:rest*/rdf:first ?blankTrg${instPostfix}.
+                ?blankSrc${index} ?blankSrcProp${index} ?inst${instPostfix}.
+                _:smth2${index} rdf:first ?blankTrg${instPostfix}.
+                BIND(?blankSrcProp${index} as ?blankTrgProp${instPostfix})
+                BIND("listHead" as ?blankType${instPostfix})
+                FILTER NOT EXISTS { _:smth3${index} rdf:rest ?inst${instPostfix} }.
+            }
+            OPTIONAL {
+                ?inst${instPostfix} rdf:type ?class${instPostfix}.
+            }
+        `;
+	}
+	const body = blankNodes.map((bn, index) => getQueryBlock(bn, index, blankNodes.length - 1)).join("\n");
+	return `${settings.defaultPrefix}
+    SELECT ?inst ?class ?label ?blankTrgProp ?blankTrg ?blankType
+        WHERE {
+           ${body}
+        }
+    `;
+}
+/**
+* Formats a chain term as an IRI, falling back to a fresh variable when the term is
+* missing or is itself a blank node, neither of which can be referenced from a query.
+*/
+function formatChainTerm(term, fallbackVariable) {
+	return isRdfIri(term) ? `<${term.value}>` : fallbackVariable;
+}
+/**
+* Answers {@link DataProvider.elements} for encoded blank nodes without querying the endpoint.
+*
+* Literal targets of the blank node are surfaced as element properties; targets which are
+* entities of their own become links instead, see {@link links}.
+*/
+function elements(elementIds, factory) {
+	const bindings = [];
+	for (const id of elementIds) {
+		const blankBindings = decodeId(id, factory);
+		if (!blankBindings) continue;
+		for (const binding of blankBindings) if (isRdfLiteral(binding.blankTrg)) bindings.push({
+			...binding,
+			propType: binding.blankTrgProp,
+			propValue: binding.blankTrg
+		});
+		else bindings.push(binding);
+	}
+	return bindings;
+}
+/**
+* Answers {@link DataProvider.links} for encoded blank nodes without querying the endpoint.
+*
+* Only links where both ends are among the requested elements are returned, matching
+* the behavior of the endpoint-backed query.
+*/
+function links(elementIds, factory) {
+	const requested = new Set(elementIds);
+	const bindings = [];
+	for (const id of elementIds) {
+		const blankBindings = decodeId(id, factory);
+		if (!blankBindings) continue;
+		for (const binding of blankBindings) {
+			const { inst, blankSrc, blankSrcProp, blankTrg, blankTrgProp } = binding;
+			if (blankSrc && blankSrcProp && requested.has(blankSrc.value)) bindings.push({
+				source: blankSrc,
+				type: blankSrcProp,
+				target: inst
+			});
+			if (!isRdfLiteral(blankTrg) && requested.has(blankTrg.value)) bindings.push({
+				source: inst,
+				type: blankTrgProp,
+				target: blankTrg
+			});
+		}
+	}
+	return bindings;
+}
+/**
+* Answers {@link DataProvider.connectedLinkStats} for an encoded blank node without
+* querying the endpoint.
+*/
+function connectedLinkStats(elementId, factory) {
+	const blankBindings = decodeId(elementId, factory);
+	if (!blankBindings) return [];
+	const stats = /* @__PURE__ */ new Map();
+	function getOrCreate(linkTypeId) {
+		let count = stats.get(linkTypeId);
+		if (!count) {
+			count = {
+				id: linkTypeId,
+				inCount: 0,
+				outCount: 0
+			};
+			stats.set(linkTypeId, count);
+		}
+		return count;
+	}
+	for (const binding of blankBindings) {
+		const { blankSrc, blankSrcProp, blankTrg, blankTrgProp } = binding;
+		if (isRdfLiteral(blankTrg)) continue;
+		if (blankSrc && blankSrcProp) {
+			const incoming = getOrCreate(blankSrcProp.value);
+			incoming.inCount += 1;
+		}
+		const outgoing = getOrCreate(blankTrgProp.value);
+		outgoing.outCount += 1;
+	}
+	return Array.from(stats.values());
+}
+/**
+* Answers {@link DataProvider.lookup} for navigation from an encoded blank node without
+* querying the endpoint, or returns `undefined` when the lookup is not about one.
+*/
+function lookup(params, factory) {
+	let bindings;
+	if (params.elementTypeId) return;
+	else if (params.refElementId && params.refElementLinkId) bindings = getAllRelatedByLinkTypeElements(params.refElementId, params.refElementLinkId, params.linkDirection, factory);
+	else if (params.refElementId) bindings = getAllRelatedElements(params.refElementId, factory);
+	else return;
+	if (bindings.length === 0) return;
+	if (params.text) {
+		const text = params.text.toLowerCase();
+		bindings = bindings.filter((binding) => binding.inst.value.toLowerCase().includes(text));
+	}
+	return {
+		head: { vars: [] },
+		results: { bindings }
+	};
+}
+/**
+* Answers the element type query for encoded blank nodes without querying the endpoint.
+*/
+function collectElementTypes$1(elementIds, factory, result) {
+	for (const id of elementIds) {
+		const blankBindings = decodeId(id, factory);
+		if (!blankBindings) continue;
+		for (const binding of blankBindings) if (binding.class) {
+			let types = result.get(id);
+			if (!types) {
+				types = /* @__PURE__ */ new Set();
+				result.set(id, types);
+			}
+			types.add(binding.class.value);
+		}
+	}
+}
+/**
+* Answers navigation from an encoded blank node over a single link type.
+*
+* The direction is relative to the blank node: `in` collects the entities which point at it,
+* `out` the entities it points at.
+*/
+function getAllRelatedByLinkTypeElements(refElementId, refElementLinkId, linkDirection, factory) {
+	const blankBindings = decodeId(refElementId, factory);
+	if (!blankBindings) return [];
+	const linkType = factory.namedNode(refElementLinkId);
+	const bindings = [];
+	for (const binding of blankBindings) {
+		const { blankSrc, blankSrcProp, blankTrg, blankTrgProp } = binding;
+		if (linkDirection !== "out" && blankSrc && blankSrcProp && blankSrcProp.value === refElementLinkId) pushRelated(bindings, blankSrc, linkType, "in", factory);
+		if (linkDirection !== "in" && blankTrgProp.value === refElementLinkId && !isRdfLiteral(blankTrg)) pushRelated(bindings, blankTrg, linkType, "out", factory);
+	}
+	return bindings;
+}
+/**
+* Answers navigation from an encoded blank node over every link type at once.
+*
+* Literal targets are left out: they are the blank node's own properties, not connections.
+*/
+function getAllRelatedElements(refElementId, factory) {
+	const blankBindings = decodeId(refElementId, factory);
+	if (!blankBindings) return [];
+	const bindings = [];
+	for (const binding of blankBindings) {
+		const { blankSrc, blankSrcProp, blankTrg, blankTrgProp } = binding;
+		if (blankSrc && blankSrcProp) pushRelated(bindings, blankSrc, blankSrcProp, "in", factory);
+		if (!isRdfLiteral(blankTrg)) pushRelated(bindings, blankTrg, blankTrgProp, "out", factory);
+	}
+	return bindings;
+}
+/**
+* Adds the element at the far end of a statement to the result: a named node as-is,
+* an encoded blank node expanded back into the statements which describe it.
+*
+* The link type and the direction are carried over so that the result describes the
+* connection the same way an endpoint-backed lookup does. A named node is returned bare,
+* without a label or a type: {@link SparqlDataProvider.lookup} fills those in, since only
+* the endpoint knows them.
+*/
+function pushRelated(bindings, term, linkType, direction, factory) {
+	const connection = {
+		link: linkType,
+		direction: factory.literal(direction)
+	};
+	const nested = isRdfIri(term) ? decodeId(term.value, factory) : void 0;
+	if (nested) for (const binding of nested) bindings.push({
+		...binding,
+		...connection
+	});
+	else bindings.push({
+		inst: term,
+		...connection
+	});
+}
+//#endregion
 //#region src/data/sparql/requestChunking.ts
 function* chunkArray(items, measure, maxChunkSize) {
 	if (!Number.isFinite(maxChunkSize)) {
@@ -6462,46 +7023,6 @@ function* chunkDirectedCrossProduct(from, to, measure, maxChunkSize, excludedTar
 	}
 }
 //#endregion
-//#region src/data/sparql/sparqlModels.ts
-function mapSparqlResponseIntoRdfJs(response, factory) {
-	function mapSparqlBinding(binding) {
-		const mapped = {};
-		for (const key in binding) if (Object.prototype.hasOwnProperty.call(binding, key)) {
-			const term = binding[key];
-			switch (term.type) {
-				case "uri":
-					mapped[key] = factory.namedNode(term.value);
-					break;
-				case "bnode":
-					mapped[key] = factory.blankNode(term.value);
-					break;
-				case "literal":
-				case "typed-literal":
-					mapped[key] = factory.literal(term.value, term["xml:lang"] ? term["xml:lang"] : term.datatype ? factory.namedNode(term.datatype) : void 0);
-					break;
-				default: throw new Error(`Unexpected SPARQL term type: "${term.type}"`);
-			}
-		}
-		return mapped;
-	}
-	return {
-		...response,
-		results: {
-			...response.results,
-			bindings: response.results.bindings.map(mapSparqlBinding)
-		}
-	};
-}
-function isRdfIri(term) {
-	return Boolean(term && term.termType === "NamedNode");
-}
-function isRdfBlank(term) {
-	return Boolean(term && term.termType === "BlankNode");
-}
-function isRdfLiteral(term) {
-	return Boolean(term && term.termType === "Literal");
-}
-//#endregion
 //#region src/data/sparql/responseHandler.ts
 var TYPE_PREDICATE = "urn:reactodia:sparql:type";
 var LABEL_PREDICATE = "urn:reactodia:sparql:label";
@@ -7036,7 +7557,7 @@ var SparqlDataProvider = class {
 	options;
 	settings;
 	queryFunction;
-	acceptBlankNodes = false;
+	acceptBlankNodes;
 	chunkMeasure;
 	linkByPredicate = /* @__PURE__ */ new Map();
 	linkById = /* @__PURE__ */ new Map();
@@ -7051,6 +7572,7 @@ var SparqlDataProvider = class {
 		this.options = options;
 		this.settings = settings;
 		this.queryFunction = queryFunction;
+		this.acceptBlankNodes = Boolean(settings.acceptBlankNodes);
 		const { chunk, queryMethod = "GET", prepareLabelPredicate, prepareImagePredicate } = this.options;
 		if (chunk) {
 			if (!Number.isSafeInteger(chunk.maxSize)) throw new Error("SparqlDataProviderOptions.chunk.maxSize should be a non-negative number");
@@ -7174,8 +7696,9 @@ var SparqlDataProvider = class {
 	}
 	async elements(params) {
 		const { elementIds, signal } = params;
+		const queriedIds = this.acceptBlankNodes ? elementIds.filter((iri) => !isEncodedBlank$1(iri)) : elementIds;
 		const triples = [];
-		if (elementIds.length > 0) await this.queryChunked(elementIds, async (batch) => {
+		if (queriedIds.length > 0) await this.queryChunked(queriedIds, async (batch) => {
 			const ids = batch.map(escapeIri).map((id) => ` (${id})`).join(" ");
 			const { defaultPrefix, dataLabelProperty, filterOnlyLanguages, elementInfoQuery } = this.settings;
 			const query = defaultPrefix + resolveTemplate(elementInfoQuery, {
@@ -7189,15 +7712,18 @@ var SparqlDataProvider = class {
 			for (const triple of response) triples.push(triple);
 		});
 		const types = this.queryManyElementTypes(this.settings.propertyConfigurations.length > 0 ? elementIds : [], signal);
-		const elementModels = getElementsInfo(triplesToElementBinding(triples), await types, this.propertyByPredicate, this.labelPredicate, this.openWorldProperties);
-		if (this.options.prepareLabels) await attachProperties(Array.from(elementModels.values()), this.options.prepareLabels, this.labelPredicate, signal);
-		if (this.options.prepareImages) await prepareElementImages(elementModels, this.options.prepareImages, this.imagePredicate, this.factory, signal);
+		const bindings = triplesToElementBinding(triples);
+		if (this.acceptBlankNodes) bindings.results.bindings.push(...elements(elementIds, this.factory));
+		const elementModels = getElementsInfo(bindings, await types, this.propertyByPredicate, this.labelPredicate, this.openWorldProperties);
+		if (this.options.prepareLabels) await attachProperties(Array.from(elementModels.values()), this.options.prepareLabels, this.labelPredicate, this.acceptBlankNodes, signal);
+		if (this.options.prepareImages) await prepareElementImages(elementModels, this.options.prepareImages, this.imagePredicate, this.factory, this.acceptBlankNodes, signal);
 		else if (this.options.imagePropertyUris && this.options.imagePropertyUris.length) await this.attachImages(elementModels, this.options.imagePropertyUris, signal);
 		return elementModels;
 	}
 	async attachImages(elements, imagePropertyIris, signal) {
 		const imageProperties = imagePropertyIris.map(escapeIri).map((id) => ` ( ${id} )`).join(" ");
-		await this.queryChunked(Array.from(elements.keys()), async (batch) => {
+		const imageableIds = Array.from(elements.keys()).filter((iri) => !(this.acceptBlankNodes && isEncodedBlank$1(iri)));
+		await this.queryChunked(imageableIds, async (batch) => {
 			const ids = batch.map((id) => ` ( ${escapeIri(id)} )`).join(" ");
 			const query = this.settings.defaultPrefix + `
                 SELECT ?inst ?linkType ?image
@@ -7219,12 +7745,14 @@ var SparqlDataProvider = class {
 		const { filterOnlyLanguages, linksInfoQuery } = this.settings;
 		const propLanguageFilter = formatLanguageFilter("?propValue", filterOnlyLanguages);
 		const linkConfigurations = this.formatLinkLinks();
+		const queriedPrimary = this.acceptBlankNodes ? primary.filter((iri) => !isEncodedBlank$1(iri)) : primary;
+		const queriedSecondary = this.acceptBlankNodes ? secondary.filter((iri) => !isEncodedBlank$1(iri)) : secondary;
 		let bindings;
-		if (primary.length > 0 && secondary.length > 0) if (linksInfoQuery.includes("${ids}")) bindings = this.queryUndirectedLinks(primary, secondary, {
+		if (queriedPrimary.length > 0 && queriedSecondary.length > 0) if (linksInfoQuery.includes("${ids}")) bindings = this.queryUndirectedLinks(queriedPrimary, queriedSecondary, {
 			propLanguageFilter,
 			linkConfigurations
 		}, signal);
-		else bindings = this.queryDirectedLinks(primary, secondary, {
+		else bindings = this.queryDirectedLinks(queriedPrimary, queriedSecondary, {
 			propLanguageFilter,
 			linkConfigurations
 		}, signal);
@@ -7235,7 +7763,13 @@ var SparqlDataProvider = class {
 			for (const iri of secondary) elementsForTypes.add(iri);
 		}
 		const types = this.queryManyElementTypes(elementsForTypes ? Array.from(elementsForTypes) : [], signal);
-		let linksInfo = getLinksInfo(await bindings, await types, this.linkByPredicate, this.openWorldLinks);
+		let allBindings = await bindings;
+		if (this.acceptBlankNodes) {
+			const connected = new Set(primary);
+			for (const iri of secondary) connected.add(iri);
+			allBindings = [...allBindings, ...links(Array.from(connected), this.factory)];
+		}
+		let linksInfo = getLinksInfo(allBindings, await types, this.linkByPredicate, this.openWorldLinks);
 		if (linkTypeIds) {
 			const allowedLinkTypes = new Set(linkTypeIds);
 			linksInfo = linksInfo.filter((link) => allowedLinkTypes.has(link.linkTypeId));
@@ -7274,6 +7808,7 @@ var SparqlDataProvider = class {
 	}
 	async connectedLinkStats(params) {
 		const { elementId, inexactCount, signal } = params;
+		if (this.acceptBlankNodes && isEncodedBlank$1(elementId)) return connectedLinkStats(elementId, this.factory);
 		const { defaultPrefix, linkTypesOfQuery, linkTypesStatisticsQuery, filterTypePattern } = this.settings;
 		const bindDirection = /\?direction\b/.test(linkTypesOfQuery);
 		const elementIri = escapeIri(elementId);
@@ -7339,11 +7874,48 @@ var SparqlDataProvider = class {
 			limit: baseParams.limit === void 0 ? 100 : baseParams.limit
 		};
 		const types = this.querySingleElementTypes(params.refElementId && this.settings.linkConfigurations.length > 0 ? params.refElementId : void 0, signal);
-		const filterQuery = this.createFilterQuery(params);
-		const linkedElements = getFilteredData(await this.executeSparqlSelect(filterQuery, { signal }), await types, this.linkByPredicate, this.labelPredicate, this.openWorldLinks);
-		if (this.options.prepareLabels) await attachProperties(linkedElements.map((linked) => linked.element), this.options.prepareLabels, this.labelPredicate, signal);
+		let bindings;
+		let navigatedFromBlank = false;
+		if (this.acceptBlankNodes) {
+			const fromBlank = lookup(params, this.factory);
+			if (fromBlank) {
+				bindings = fromBlank;
+				navigatedFromBlank = true;
+			} else bindings = await updateLookupResults(await this.executeSparqlSelect(this.createFilterQuery(params), { signal }), (blankQuery) => this.executeSparqlSelect(blankQuery, { signal }), this.settings, this.factory);
+		} else {
+			const filterQuery = this.createFilterQuery(params);
+			bindings = await this.executeSparqlSelect(filterQuery, { signal });
+		}
+		const linkedElements = getFilteredData(bindings, await types, this.linkByPredicate, this.labelPredicate, this.openWorldLinks);
+		if (navigatedFromBlank) return this.attachNeighborInfo(linkedElements, signal);
+		if (this.options.prepareLabels) await attachProperties(linkedElements.map((linked) => linked.element), this.options.prepareLabels, this.labelPredicate, this.acceptBlankNodes, signal);
 		return linkedElements;
 	}
+	/**
+	* Fills in the data of the elements found by navigating from a blank node.
+	*
+	* The navigation is answered by decoding the blank node IRI, which knows only the term
+	* at the far end of each statement, so everything else about a named neighbor - its
+	* label, types and properties - still has to be read from the endpoint. Without this
+	* the neighbor would render as its bare IRI.
+	*
+	* {@link elements} applies the {@link SparqlDataProviderOptions.prepareLabels} hook
+	* itself, so the caller must not apply it again.
+	*/
+	async attachNeighborInfo(items, signal) {
+		if (items.length === 0) return [];
+		const elementModels = await this.elements({
+			elementIds: items.map((item) => item.element.id),
+			signal
+		});
+		return items.map((item) => {
+			const element = elementModels.get(item.element.id);
+			return element ? {
+				...item,
+				element
+			} : item;
+		});
+	}
 	createFilterQuery(params) {
 		if (!params.refElementId && params.refElementLinkId) throw new Error("Cannot execute refElementLink filter without refElement");
 		let outerProjection = "?inst ?class ?label";
@@ -7369,10 +7941,14 @@ var SparqlDataProvider = class {
 			filterByType = this.settings.filterTypePattern.replace(/[?$]class\b/g, elementTypeIri);
 		}
 		const { defaultPrefix, dataLabelProperty, lookupQuery, filterOnlyLanguages, filterElementInfoPattern, fullTextSearch } = this.settings;
-		const queryElementInfo = resolveTemplate(filterElementInfoPattern, {
+		let queryElementInfo = resolveTemplate(filterElementInfoPattern, {
 			dataLabelProperty,
 			labelLanguageFilter: formatLanguageFilter("?label", filterOnlyLanguages)
 		});
+		if (this.acceptBlankNodes) {
+			outerProjection += ` ${BLANK_NODE_QUERY_PARAMETERS}`;
+			queryElementInfo += BLANK_NODE_QUERY;
+		}
 		let filterByText = "";
 		let orderBy = "";
 		if (params.text) {
@@ -7500,7 +8076,12 @@ var SparqlDataProvider = class {
 		if (elements.length === 0) return /* @__PURE__ */ new Map();
 		const { filterTypePattern } = this.settings;
 		const elementTypes = /* @__PURE__ */ new Map();
-		await this.queryChunked(elements, async (batch) => {
+		let queriedElements = elements;
+		if (this.acceptBlankNodes) {
+			queriedElements = elements.filter((iri) => !isEncodedBlank$1(iri));
+			collectElementTypes$1(elements, this.factory, elementTypes);
+		}
+		await this.queryChunked(queriedElements, async (batch) => {
 			const query = resolveTemplate("SELECT ?inst ?class { VALUES(?inst) { ${ids} } ${filterTypePattern} }", {
 				ids: batch.map((iri) => `(${escapeIri(iri)})`).join(" "),
 				filterTypePattern
@@ -7523,15 +8104,16 @@ async function attachLabels(items, fetchLabels, signal) {
 		if (itemLabels) item.label = itemLabels;
 	}
 }
-async function attachProperties(items, fetchProperties, propertyIri, signal) {
-	const properties = await fetchProperties(new Set(items.map((item) => item.id)), signal);
-	for (const item of items) {
+async function attachProperties(items, fetchProperties, propertyIri, acceptBlankNodes, signal) {
+	const resolvable = acceptBlankNodes ? items.filter((item) => !isEncodedBlank(item.id)) : items;
+	const properties = await fetchProperties(new Set(resolvable.map((item) => item.id)), signal);
+	for (const item of resolvable) {
 		const itemValues = properties.get(item.id);
 		if (itemValues) item.properties[propertyIri] = itemValues;
 	}
 }
-function prepareElementImages(elements, fetchImages, imagePropertyIri, factory, signal) {
-	return fetchImages(elements.values(), signal).then((images) => {
+function prepareElementImages(elements, fetchImages, imagePropertyIri, factory, acceptBlankNodes, signal) {
+	return fetchImages(acceptBlankNodes ? Array.from(elements.values()).filter((element) => !isEncodedBlank(element.id)) : elements.values(), signal).then((images) => {
 		for (const [iri, image] of images) {
 			const entity = elements.get(iri);
 			if (entity) appendProperty(entity.properties, imagePropertyIri, factory.namedNode(image));
@@ -30655,15 +31237,15 @@ class ServiceProvider {
     /**
      * Returns the instance of the given service type, creating and caching it on first request.
      *
-     * @param type The service type to retrieve.
+     * @param serviceClass The service type to retrieve.
      * @returns The shared instance of the service.
      * @template T The type of the service to retrieve.
      */
-    static get(type) {
-        if (!ServiceProvider.SERVICE_INSTANCES.has(type.ID)) {
-            ServiceProvider.SERVICE_INSTANCES.set(type.ID, new type());
+    static get(serviceClass) {
+        if (!ServiceProvider.SERVICE_INSTANCES.has(serviceClass.ID)) {
+            ServiceProvider.SERVICE_INSTANCES.set(serviceClass.ID, new serviceClass());
         }
-        return ServiceProvider.SERVICE_INSTANCES.get(type.ID);
+        return ServiceProvider.SERVICE_INSTANCES.get(serviceClass.ID);
     }
 }
 ServiceProvider.SERVICE_INSTANCES = new Map();
@@ -30806,6 +31388,28 @@ let DiagramStorageService = DiagramStorageService_1 = class DiagramStorageServic
     clear() {
         this.storage.removeItem(DiagramStorageService_1.STORAGE_KEY);
     }
+    /**
+     * Reads back the blank node toggle, defaulting to `false` when nothing is stored.
+     *
+     * The flag has to survive a reload: a restored diagram can hold blank node elements, and
+     * their IRIs can only be resolved while the data provider accepts blank nodes - the endpoint
+     * knows nothing about them.
+     *
+     * TEMPORARY, remove together with the blank node checkbox in `graphwise-reactodia.tsx`.
+     * Only the checkbox needs this. In production the flag arrives on the `providerSettings`
+     * prop, which the host supplies on every mount, so there is nothing to persist.
+     */
+    loadAcceptBlankNodes() {
+        return this.storage.getItem(DiagramStorageService_1.ACCEPT_BLANK_NODES_KEY) === 'true';
+    }
+    /**
+     * Persists the blank node toggle.
+     *
+     * TEMPORARY, see {@link loadAcceptBlankNodes}.
+     */
+    saveAcceptBlankNodes(acceptBlankNodes) {
+        this.storage.setItem(DiagramStorageService_1.ACCEPT_BLANK_NODES_KEY, String(acceptBlankNodes));
+    }
     /**
      * Local storage getter
      */
@@ -30815,6 +31419,7 @@ let DiagramStorageService = DiagramStorageService_1 = class DiagramStorageServic
 };
 DiagramStorageService.ID = 'DiagramStorageService';
 DiagramStorageService.STORAGE_KEY = 'diagram.state';
+DiagramStorageService.ACCEPT_BLANK_NODES_KEY = 'diagram.accept-blank-nodes';
 DiagramStorageService = DiagramStorageService_1 = __decorate$1([
     Service
 ], DiagramStorageService);
@@ -30882,6 +31487,60 @@ class SubscriptionList {
     }
 }
 
+const NODE_COLOR_VARIABLES = [
+    '--gw-foreground-visual-diagram-categorical-01',
+    '--gw-foreground-visual-diagram-categorical-02',
+    '--gw-foreground-visual-diagram-categorical-03',
+    '--gw-foreground-visual-diagram-categorical-04',
+    '--gw-foreground-visual-diagram-categorical-05',
+    '--gw-foreground-visual-diagram-categorical-06',
+    '--gw-foreground-visual-diagram-categorical-07',
+    '--gw-foreground-visual-diagram-categorical-08',
+    '--gw-foreground-visual-diagram-categorical-09',
+    '--gw-foreground-visual-diagram-categorical-10',
+    '--gw-foreground-visual-diagram-categorical-11',
+    '--gw-foreground-visual-diagram-categorical-12',
+    '--gw-foreground-visual-diagram-categorical-13',
+    '--gw-foreground-visual-diagram-categorical-14',
+    '--gw-foreground-visual-diagram-categorical-15',
+    '--gw-foreground-visual-diagram-categorical-16',
+    '--gw-foreground-visual-diagram-categorical-17',
+    '--gw-foreground-visual-diagram-categorical-18',
+    '--gw-foreground-visual-diagram-categorical-19',
+    '--gw-foreground-visual-diagram-categorical-20'
+];
+/**
+ * Color slot assigned to each type, in the order the types are first seen.
+ */
+const typeToIndex = new Map();
+function getColor(variable) {
+    return getComputedStyle(document.documentElement).getPropertyValue(variable).trim();
+}
+/**
+ * Colors an element by its type: each type takes the next color from the palette, which wraps
+ * around once it runs out
+ *
+ * Returns `undefined` for elements without a type (placeholders and other non-entity elements) and
+ * when the host does not define the palette, leaving Reactodia to fall back to its own hash-based
+ * colors.
+ */
+const resolveTypeStyle = (types) => {
+    const type = types[0];
+    if (!type) {
+        return undefined;
+    }
+    let index = typeToIndex.get(type);
+    if (index === undefined) {
+        index = typeToIndex.size;
+        typeToIndex.set(type, index);
+    }
+    const color = getColor(NODE_COLOR_VARIABLES[index % NODE_COLOR_VARIABLES.length]);
+    return color ? { color } : undefined;
+};
+const resetColors = () => {
+    typeToIndex.clear();
+};
+
 /**
  * Reactodia ships English as its built-in default bundle, so English needs no override.
  * Other languages are layered on top as partial bundles; unknown codes fall back to English.
@@ -30908,7 +31567,7 @@ const subscriptions = new SubscriptionList();
 /**
  * Builds a Reactodia {@link SparqlDataProvider} for the given endpoint using the supplied
  * query preset. The host owns the query configuration and passes it in via props; when none
- * is provided we fall back to Reactodia's generic {@link OwlRdfsSettings} OWL/RDFS preset.
+ * is provided we fall back to Reactodia's generic {@link OwlStatsSettings} OWL/RDFS preset.
  */
 function createDataProvider(props) {
     const { currentRepository, config, providerSettings } = props;
@@ -30916,7 +31575,7 @@ function createDataProvider(props) {
         endpointUrl: currentRepository,
         queryMethod: 'POST',
         queryFunction: config.queryFunction
-    }, providerSettings);
+    }, Object.assign(Object.assign({}, OwlStatsSettings), providerSettings));
 }
 /**
  * Places the seed entities on the canvas. Each IRI is added as a placeholder element, and data is then loaded for the
@@ -31004,7 +31663,7 @@ function ReactodiaApp(props) {
         if (isReload) {
             // Simply reload without using the current state. This may happen when the user switches the language at runtime.
             // since there is no existing mechanism to re-translate the UI at runtime (not for the UI labels at least)
-            await model.importLayout({ dataProvider, diagram: currentDiagram, signal });
+            await model.importLayout({ dataProvider, diagram: currentDiagram, signal, validateLinks: true });
         }
         else if ((_a = config.seedIris) === null || _a === void 0 ? void 0 : _a.length) {
             await seedIrisToCanvas(context, dataProvider, config.seedIris, signal);
@@ -31015,7 +31674,7 @@ function ReactodiaApp(props) {
         else {
             // Restore the previously saved layout when present, otherwise start empty. Either way this binds the
             // data provider (savedDiagram is undefined -> empty diagram), so the unified search/lookup works.
-            await model.importLayout({ dataProvider, diagram: savedDiagram, signal });
+            await model.importLayout({ dataProvider, diagram: savedDiagram, signal, validateLinks: true });
         }
     }, [language]);
     /**
@@ -31032,7 +31691,8 @@ function ReactodiaApp(props) {
         ref: onMount,
         defaultLayout: blockingDefaultLayout,
         defaultLanguage: language,
-        translations: translationsForLanguage(language)
+        translations: translationsForLanguage(language),
+        typeStyleResolver: resolveTypeStyle
     }, reactExports.createElement(DefaultWorkspace, {}));
 }
 /**
@@ -31070,7 +31730,7 @@ function unmountReactodia(root) {
     root.unmount();
 }
 
-const graphwiseReactodiaCss = "graphwise-reactodia{display:block;width:100%;height:75vh}graphwise-reactodia .reactodia-container{position:relative;width:100%;height:100%}";
+const graphwiseReactodiaCss = "graphwise-reactodia{display:flex;flex-direction:column;width:100%;height:75vh}graphwise-reactodia .blank-nodes-toggle{display:flex;align-items:center;gap:4px;padding:4px 8px}graphwise-reactodia .reactodia-container{position:relative;flex:1;min-height:0;width:100%}";
 
 const GraphwiseReactodia = class {
     constructor(hostRef) {
@@ -31079,6 +31739,19 @@ const GraphwiseReactodia = class {
          * UI language code (e.g. `en`, `fr`) for the Reactodia interface. Defaults to English.
          */
         this.language = LanguageKey.EN;
+        /**
+         * Runtime toggle for the data provider's `acceptBlankNodes` flag, for testing blank node
+         * support against a live endpoint. Internal, not part of the public API - in production the
+         * host sets `acceptBlankNodes` through the {@link providerSettings} prop instead.
+         *
+         * TEMPORARY. Removing the checkbox means removing, in this file: this field, the
+         * `blank-nodes-toggle` label in {@link render}, {@link onAcceptBlankNodesChange}, the
+         * `acceptBlankNodes` override handed to `mountReactodia`, and the {@link graphContainer} /
+         * {@link componentDidLoad} pair - the graph mounted straight into the host element before
+         * the toggle needed a sibling. Then `.blank-nodes-toggle` in the stylesheet, and
+         * `loadAcceptBlankNodes` / `saveAcceptBlankNodes` on {@link DiagramStorageService}.
+         */
+        this.acceptBlankNodes = service(DiagramStorageService).loadAcceptBlankNodes();
     }
     onProviderSettingsChange() {
         this.renderGraph();
@@ -31088,7 +31761,12 @@ const GraphwiseReactodia = class {
         // to re-translate the UI is to re-create the graph.
         this.renderGraph(true);
     }
-    connectedCallback() {
+    onThemeChange() {
+        resetColors();
+        this.renderGraph(true);
+    }
+    // The graph container is only available after the first render, so the initial mount happens here.
+    componentDidLoad() {
         if (this.config) {
             this.renderGraph();
         }
@@ -31100,7 +31778,20 @@ const GraphwiseReactodia = class {
         }
     }
     render() {
-        return (index$1.h(index$1.Host, { key: 'b33d3709a5d7b1fdde8d528d036d9dbc962d6c76' }));
+        return (index$1.h(index$1.Host, { key: 'dbb9526355787bc4a7952d7faff2fc23666b6cfd' }, index$1.h("label", { key: '755311e40eb8b043a3077553389ee11e1d322782', class: "blank-nodes-toggle" }, index$1.h("input", { key: '42581ef35034da73b28b3e3e369888f8fa2b92a0', type: "checkbox", "data-test": "accept-blank-nodes", checked: this.acceptBlankNodes, onChange: (event) => this.onAcceptBlankNodesChange(event) }), "Accept blank nodes"), index$1.h("div", { key: '67ca64a44b0f4692a0ed05a3984babc0e0cd646b', class: "reactodia-container", ref: (element) => this.graphContainer = element })));
+    }
+    /**
+     * The flag is read when the provider is constructed, so the toggle rebuilds the provider,
+     * which resets the canvas. That is the same path the host takes when it changes
+     * {@link providerSettings}.
+     *
+     * It is also persisted, so that a diagram restored from the local store is loaded by a
+     * provider which can still resolve the blank nodes it holds.
+     */
+    onAcceptBlankNodesChange(event) {
+        this.acceptBlankNodes = event.target.checked;
+        service(DiagramStorageService).saveAcceptBlankNodes(this.acceptBlankNodes);
+        this.renderGraph();
     }
     renderGraph(isReloading) {
         var _a;
@@ -31110,7 +31801,7 @@ const GraphwiseReactodia = class {
         if (!((_a = this.config) === null || _a === void 0 ? void 0 : _a.queryFunction)) {
             throw new Error('config.queryFunction is required');
         }
-        if (!this.hostElement) {
+        if (!this.graphContainer) {
             return;
         }
         const props = {
@@ -31118,20 +31809,21 @@ const GraphwiseReactodia = class {
             currentRepository: this.currentRepository,
             config: this.config,
             language: this.language,
-            providerSettings: this.providerSettings,
+            // The toggle wins over the host setting, so it stays applied when the provider is rebuilt.
+            providerSettings: Object.assign(Object.assign({}, this.providerSettings), { acceptBlankNodes: this.acceptBlankNodes }),
         };
         if (this.reactRoot && !isReloading) {
             void updateReactodia(props);
         }
         else {
-            this.reactRoot = mountReactodia(this.hostElement, props);
+            this.reactRoot = mountReactodia(this.graphContainer, props);
         }
     }
-    get hostElement() { return index$1.getElement(this); }
     static get watchers() { return {
         "currentRepository": ["onProviderSettingsChange"],
         "providerSettings": ["onProviderSettingsChange"],
-        "language": ["onLanguageChange"]
+        "language": ["onLanguageChange"],
+        "theme": ["onThemeChange"]
     }; }
 };
 GraphwiseReactodia.style = graphwiseReactodiaCss;