feat!: retirer readUnion de la surface publiee, et lire un document par requete ancree

readUnion etait N requetes ancrees plus une politique de lot : une lecture
qui echoue avalee en reponse vide, un document dont on ne detient pas la cle
ecarte au lieu d'etre refuse, un regroupement en sacs de proprietes, et le
filtrage du prefixe reserve. Rien en amont ne repond a cette composition, et
son annotation citait sparql_query -- une citation exacte attachee a une
affirmation fausse. Une composition ne s'aligne pas sur une fonction.

Ce qui reste est ce qu'il y avait dessous : docs.sparqlQuery ancre sur un
document, qui va deja chercher la cle servie par le magasin public -- donc
une reference nue suffit toujours pour lire un document public, sans rien
changer a useShapeQuery. Lire plusieurs documents, c'est cet appel une fois
par document, et la tolerance a une lecture qui echoue revient a l'appelant,
la ou l'amont la laisse : une requete ancree sur un depot que le verifier ne
detient pas rejette.

Cote src, l'unique lecture interne restante devient read-document.ts : un
document, une requete ancree, precedee de l'ouverture du depot -- barriere
que index-deposit consulte pour distinguer une absence d'un depot non
synchronise. Le harnais e2e et l'exemple composent la leur, avec leur catch
visible au point d'appel.

Version majeure : 1.0.0-dev.8.

examples/notebook/app.ts

@@ -34,7 +34,6 @@ import {
   ensureIdentity,
   inbox,
   init,
-  readUnion,
   storeRegistry,
   subscribeDoc,
   initNg as initNgSignals,
@@ -237,12 +236,30 @@ function currentNotes(): Note[] {
  * to change when the real SDK takes that same string.
  */
 async function readSharedNote(reference: string): Promise<Note | null> {
-  const [note] = await readUnion([reference]);
-  if (!note) return null;
+  const s = await sessionReady;
+  // ONE anchored query, naming the note. The anchor scopes the read to that document's
+  // own graph, so the body carries no `GRAPH <...>` wrapper; the library asks the public
+  // store for the key on the way in, which is what makes a bare reference enough.
+  //
+  // This was `readUnion([reference])` until `1.0.0-dev.8`. What an application composes
+  // itself now is the projection below - the SELECT and the grouping - because the
+  // primitive that did it was a batch nothing upstream answers.
+  const result = await docs.sparqlQuery(
+    s.session_id,
+    "SELECT ?s ?p ?o WHERE { ?s ?p ?o }",
+    undefined,
+    reference,
+  );
+  const rows =
+    (result as { results?: { bindings?: Array<Record<string, { value: string }>> } })
+      .results?.bindings ?? [];
+  const values = (predicate: string): string[] =>
+    rows.filter((r) => r["p"]?.value === predicate).map((r) => r["o"]!.value);
+  if (rows.length === 0) return null;
   return {
-    doc: note.graph,
-    title: note.props[TITLE]?.[0] ?? "(sans titre)",
-    body: note.props[BODY]?.[0] ?? "",
+    doc: reference as Nuri,
+    title: values(TITLE)[0] ?? "(sans titre)",
+    body: values(BODY)[0] ?? "",
   };
 }