graphwise-reactodia 0.0.1-TR10 → 0.0.1-TR12

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

@@ -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";
@@ -6780,7 +7301,7 @@ function typeMatchesDomain(config, types) {
 function enrichElement(element, binding, labelPredicate) {
 	if (!element) return;
 	if (binding.label) appendProperty(element.properties, labelPredicate, binding.label);
-	if (binding.class && element.types.indexOf(binding.class.value) < 0) element.types.push(binding.class.value);
+	if (isRdfIri(binding.class) && element.types.indexOf(binding.class.value) < 0) element.types.push(binding.class.value);
 	if (binding.propType && binding.propValue && binding.propType.value !== LABEL_PREDICATE) appendProperty(element.properties, binding.propType.value, binding.propValue);
 }
 function appendLabel(container, newLabel) {
@@ -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));
@@ -23286,6 +23868,35 @@ function ToolbarAction(props) {
 	});
 }
 /**
+* Toolbar action component to open a file selection dialog.
+*
+* @category Components
+*/
+function ToolbarActionOpen(props) {
+	const { className, fileAccept, onSelect, children, ...otherProps } = props;
+	const inputRef = reactExports.useRef(null);
+	return /* @__PURE__ */ jsxRuntimeExports.jsxs(jsxRuntimeExports.Fragment, { children: [/* @__PURE__ */ jsxRuntimeExports.jsx(ToolbarAction, {
+		...otherProps,
+		className: clsx(className, `${CLASS_NAME$8}__open`),
+		onSelect: () => {
+			inputRef.current?.click();
+		},
+		children
+	}), /* @__PURE__ */ jsxRuntimeExports.jsx("input", {
+		ref: inputRef,
+		role: "none",
+		type: "file",
+		className: `${CLASS_NAME$8}__open-input`,
+		accept: fileAccept,
+		onChange: (e) => {
+			if (e.currentTarget.files) {
+				const file = e.currentTarget.files[0];
+				onSelect(file);
+			}
+		}
+	})] });
+}
+/**
 * Toolbar action component to clear diagram content.
 *
 * Clearing the diagram adds a command to the command history.
@@ -30264,6 +30875,16 @@ function getContentFittingBoxForLayout(state) {
 	};
 }
 
+const graphwise_toolbar_action$1 = {
+	"download_diagram.label": "Export to JSON",
+	"download_diagram.title": "Export the diagram to a JSON file",
+	"upload_diagram.label": "Import from JSON",
+	"upload_diagram.title": "Replace the diagram with one from a JSON file"
+};
+var enTranslation = {
+	graphwise_toolbar_action: graphwise_toolbar_action$1
+};
+
 const authoring_state = {
 	"entity_action_delete.label": "supprimer",
 	"entity_action_delete.title": "Supprimer l'entité",
@@ -30518,6 +31139,12 @@ const standard_link = {
 const toolbar = {
 	"menu_toggle.title": "Ouvrir le menu"
 };
+const graphwise_toolbar_action = {
+	"download_diagram.label": "Exporter en JSON",
+	"download_diagram.title": "Exporter le diagramme en fichier JSON",
+	"upload_diagram.label": "Importer depuis JSON",
+	"upload_diagram.title": "Remplacer le diagramme par celui d'un fichier JSON"
+};
 const toolbar_action = {
 	"clear_all.command": "Tout effacer",
 	"clear_all.title": "Supprimer tous les éléments et liens du diagramme",
@@ -30628,6 +31255,7 @@ var frTranslation = {
 	standard_element: standard_element,
 	standard_link: standard_link,
 	toolbar: toolbar,
+	graphwise_toolbar_action: graphwise_toolbar_action,
 	toolbar_action: toolbar_action,
 	unified_search: unified_search,
 	visual_authoring: visual_authoring,
@@ -30642,8 +31270,10 @@ var LanguageKey;
     LanguageKey["FR"] = "fr";
 })(LanguageKey || (LanguageKey = {}));
 
-// English is provided by default from reactodia so we don't need to include it here, unless we override it
+// English is provided by default from reactodia, so the English bundle holds only our own keys and overrides. If
+// A key is missing, reactodia defaults to its own translation.
 const TRANSLATIONS = {
+    [LanguageKey.EN]: enTranslation,
     [LanguageKey.FR]: frTranslation
 };
 
@@ -30703,7 +31333,7 @@ function Service(_serviceClass) {
     // no implementation needed. We only use the type checking of the parameter
 }
 
-var __decorate$3 = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+var __decorate$4 = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
@@ -30714,6 +31344,20 @@ var DiagramService_1;
  * Service for diagram related operations and subscriptions
  */
 let DiagramService = DiagramService_1 = class DiagramService {
+    /**
+     * Replaces the diagram content with the given serialization. Element data is requested from the data provider and
+     * the links between the imported elements are validated against it.
+     *
+     * @param model The diagram model to import into.
+     * @param dataProvider The data provider to bind to the diagram.
+     * @param diagram The serialization to import. When `undefined`, the diagram is cleared.
+     * @param signal Optional signal to abort the import.
+     */
+    importDiagram(model, dataProvider, diagram, signal) {
+        // selection is not cleared on import, so we clear it manually to avoid painting the previous selection
+        model.setSelection([]);
+        return model.importLayout({ dataProvider, diagram, signal, validateLinks: true });
+    }
     /**
      * Subscribes to diagram changes. On every debounced change the current layout is
      * exported and passed to the callback.
@@ -30748,11 +31392,11 @@ let DiagramService = DiagramService_1 = class DiagramService {
 DiagramService.ID = 'DiagramService';
 DiagramService.NOTIFY_DEBOUNCE_MS = 300;
 DiagramService.HISTORY_CHANGED_EVENT = 'historyChanged';
-DiagramService = DiagramService_1 = __decorate$3([
+DiagramService = DiagramService_1 = __decorate$4([
     Service
 ], DiagramService);
 
-var __decorate$2 = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+var __decorate$3 = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
@@ -30767,11 +31411,11 @@ let WindowService = class WindowService {
     }
 };
 WindowService.ID = 'WindowService';
-WindowService = __decorate$2([
+WindowService = __decorate$3([
     Service
 ], WindowService);
 
-var __decorate$1 = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+var __decorate$2 = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
@@ -30815,11 +31459,11 @@ let DiagramStorageService = DiagramStorageService_1 = class DiagramStorageServic
 };
 DiagramStorageService.ID = 'DiagramStorageService';
 DiagramStorageService.STORAGE_KEY = 'diagram.state';
-DiagramStorageService = DiagramStorageService_1 = __decorate$1([
+DiagramStorageService = DiagramStorageService_1 = __decorate$2([
     Service
 ], DiagramStorageService);
 
-var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+var __decorate$1 = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
@@ -30842,7 +31486,7 @@ let EventService = class EventService {
     }
 };
 EventService.ID = 'EventService';
-EventService = __decorate([
+EventService = __decorate$1([
     Service
 ], EventService);
 
@@ -30936,8 +31580,102 @@ const resetColors = () => {
     typeToIndex.clear();
 };
 
+var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var DiagramFileService_1;
+/**
+ * Service for downloading and uploading the diagram as a file. The file content is the same
+ * {@link SerializedDiagram} that is persisted to the local store.
+ */
+let DiagramFileService = DiagramFileService_1 = class DiagramFileService {
+    /**
+     * Downloads the given diagram serialization as a file with the given name.
+     */
+    download(diagram, fileName) {
+        const window = service(WindowService).getWindow();
+        const blob = new Blob([JSON.stringify(diagram)], { type: DiagramFileService_1.MIME_TYPE });
+        const url = window.URL.createObjectURL(blob);
+        const link = window.document.createElement('a');
+        link.href = url;
+        link.download = fileName;
+        link.click();
+        window.URL.revokeObjectURL(url);
+    }
+    /**
+     * Reads a diagram serialization from the given file.
+     *
+     * @throws Error when the file is not valid JSON or is not a serialized diagram.
+     */
+    async read(file) {
+        let diagram;
+        try {
+            diagram = JSON.parse(await file.text());
+        }
+        catch (error) {
+            throw new Error(`File "${file.name}" is not valid JSON: ${error.message}`);
+        }
+        if (!this.isSerializedDiagram(diagram)) {
+            throw new Error(`File "${file.name}" is not a serialized diagram`);
+        }
+        return diagram;
+    }
+    /**
+     * Checks if the provided value is a serialized diagram
+     */
+    isSerializedDiagram(value) {
+        var _a, _b;
+        const diagram = value;
+        return (diagram === null || diagram === void 0 ? void 0 : diagram['@type']) === 'Diagram'
+            && Array.isArray((_a = diagram.layoutData) === null || _a === void 0 ? void 0 : _a.elements)
+            && Array.isArray((_b = diagram.layoutData) === null || _b === void 0 ? void 0 : _b.links);
+    }
+};
+DiagramFileService.ID = 'DiagramFileService';
+DiagramFileService.FILE_EXTENSION = '.json';
+DiagramFileService.MIME_TYPE = 'application/json';
+DiagramFileService = DiagramFileService_1 = __decorate([
+    Service
+], DiagramFileService);
+
+/**
+ * The workspace main menu: Reactodia's default actions, followed by the diagram download and upload.
+ *
+ * Passing a `menu` to the `DefaultWorkspace` replaces its default actions, so they are listed here again.
+ * Rendered inside the workspace, so the actions can use the workspace hooks.
+ */
+function GraphwiseMenu() {
+    const { model } = useWorkspace();
+    const t = useTranslation();
+    const diagramFileService = service(DiagramFileService);
+    const diagramService = service(DiagramService);
+    const downloadDiagram = () => {
+        const timestamp = new Date().toISOString().replace(/[-:]|\.\d+Z$/g, '');
+        diagramFileService.download(model.exportLayout(), `diagram-${timestamp}${DiagramFileService.FILE_EXTENSION}`);
+    };
+    const uploadDiagram = async (file) => {
+        try {
+            const diagram = await diagramFileService.read(file);
+            await diagramService.importDiagram(model, model.dataProvider, diagram);
+        }
+        catch (error) {
+            console.error('Failed to upload the diagram', error);
+        }
+    };
+    return reactExports.createElement(reactExports.Fragment, null, reactExports.createElement(ToolbarActionClearAll, {}), reactExports.createElement(ToolbarActionExport, { kind: 'exportRaster' }), reactExports.createElement(ToolbarActionExport, { kind: 'exportSvg' }), reactExports.createElement(ToolbarActionExport, { kind: 'print' }), reactExports.createElement(ToolbarAction, 
+    // The same icon as ToolbarActionSave. We dont use that action, since it disables saving on refresh
+    { className: 'reactodia-toolbar-action__save', title: t.text('graphwise_toolbar_action.download_diagram.title'), onSelect: downloadDiagram }, t.text('graphwise_toolbar_action.download_diagram.label')), reactExports.createElement(ToolbarActionOpen, {
+        title: t.text('graphwise_toolbar_action.upload_diagram.title'),
+        fileAccept: DiagramFileService.FILE_EXTENSION,
+        onSelect: (file) => void uploadDiagram(file)
+    }, t.text('graphwise_toolbar_action.upload_diagram.label')));
+}
+
 /**
- * Reactodia ships English as its built-in default bundle, so English needs no override.
+ * Reactodia ships English as its built-in default bundle, so the English bundle only adds our own keys.
  * Other languages are layered on top as partial bundles; unknown codes fall back to English.
  *
  * Reactodia never re-reads the translations, so the component must be remounted
@@ -31055,10 +31793,11 @@ function ReactodiaApp(props) {
         const dataProvider = createDataProvider(props);
         const isReload = props.isReload;
         const savedDiagram = service(DiagramStorageService).load();
+        const diagramService = service(DiagramService);
         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, validateLinks: true });
+            await diagramService.importDiagram(model, dataProvider, currentDiagram, signal);
         }
         else if ((_a = config.seedIris) === null || _a === void 0 ? void 0 : _a.length) {
             await seedIrisToCanvas(context, dataProvider, config.seedIris, signal);
@@ -31069,7 +31808,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, validateLinks: true });
+            await diagramService.importDiagram(model, dataProvider, savedDiagram, signal);
         }
     }, [language]);
     /**
@@ -31088,7 +31827,7 @@ function ReactodiaApp(props) {
         defaultLanguage: language,
         translations: translationsForLanguage(language),
         typeStyleResolver: resolveTypeStyle
-    }, reactExports.createElement(DefaultWorkspace, {}));
+    }, reactExports.createElement(DefaultWorkspace, { menu: reactExports.createElement(GraphwiseMenu) }));
 }
 /**
  * Mounts the Reactodia application into the given container and returns the React root.