feat: un document en store public sert son ReadCap, une référence nue suffit

Le modèle amont est explicite dans `PublicRepoLinkV0` : le lien ne porte AUCUN
`read_cap`, et son commentaire dit pourquoi — *"The latest ReadCap of the branch
will be downloaded from the outerOverlay, if the peer brokers listed below allow
it […] the public site are served differently by brokers"*
(engine/net/src/types.rs:5098). La clé n'est pas remise par un émetteur : elle est
donnée par le réseau à qui la demande, parce que le broker a épinglé l'overlay
externe (`expose_outer`).

La bibliothèque refusait jusqu'ici la forme sans cap quel que soit le store. Sûr
dans le bon sens, mais une application ne pouvait pas exprimer « fais circuler, la
référence suffit » — le seul acte que le modèle rend gratuit — et son unique
contournement était de distribuer la clé, ce qui détruit la confidentialité
composable.

`emulated-verifier/public-store.ts` émule le mécanisme SANS toucher à la garde. La
possession reste l'unique critère : un document public est lisible non par exception
mais parce que son cap est *obtenable*. Chaque porte de lecture demande d'abord
(`readUnion`, `docs.sparqlQuery`, `ensureRepoOpen`, `documentInboxAddress`), puis le
chemin ordinaire s'applique.

Lire n'est pas écrire. Ce que le store sert est un droit de LECTURE :
`learnFromPublicStore` le classe à part et `assertMayWrite` refuse l'écriture
dessus. Sans cela une référence nue achetait une écriture, ce qu'aucun store amont
n'accorde.

Autres conséquences :

- `recordInPublicStore` (marquer + frapper) devient `markInPublicStore` (marquer).
  Frapper un second cap à côté de celui qu'on vient de télécharger donnerait deux
  clés différentes le jour où la constante devient un secret.
- `hasCap` quitte la porte polyfill : il se lisait « ai-je le droit de lire ceci ? »
  et un document public y répondait `false` jusqu'à ce qu'on demande son cap. Aucun
  appelant hors des tests.
- Les tests cross-user ne font plus traverser de cap par une variable JS : Bob
  n'obtient que la référence nue, comme une vraie application.

Écarts documentés plutôt que masqués : le pari sur un modèle DÉCLARÉ (`expose_outer`
est câblé à `false` côté client et `ExtTopicSyncReq` est `unimplemented!()`), la
découverte limitée à ce qu'on sait déjà nommer, `useShape` qui n'a pas d'await à
dépenser, et l'absence de `locator`.

179 tests unitaires, e2e 42/42 contre le broker en ligne.

packages/client/test/isolation-active.test.ts

@@ -11,16 +11,17 @@
  * What the read filter then shows:
  *   (a) a document nobody shared is unreadable, and stays unreadable for a third
  *       party after a share to someone else — sharing is per-document, per-inbox;
- *   (b) a bare reference grants NOTHING (naming is not reading), while the repo
- *       link of a published document opens it for whoever receives it;
+ *   (b) the read-filtered VIEW decides on possession alone — it is synchronous, so it
+ *       asks no store anything (a public store WOULD serve its cap; that is proven on
+ *       the read paths, in `cross-user-access.test.ts`);
  *   (c) switching identity SWITCHES heldByHolder — it never wipes one.
  */
 import { getCaps } from "../src/shared-wallet/bootstrap";
 import { test, expect, mock, afterAll } from "bun:test";
 import { createEntityDoc, resetRegistryCache, userInbox, listMyEntityDocs } from "../src/shared-wallet/account-registry";
 import type { RegistrySession } from "../src/shared-wallet/account-registry";
-import type { ReadCap } from "../src/model/types";
-import {configure,configureStoreRegistry,resetStoreRegistry,resetConfig,hasCap,resetCaps,setCurrentUser,share} from "../src/polyfill";
+import type { Nuri, ReadCap } from "../src/model/types";
+import {configure,configureStoreRegistry,resetStoreRegistry,resetConfig,resetCaps,setCurrentUser,share} from "../src/polyfill";
 import { read as readInbox } from "../src/surface/inbox";
 import { filterReadable } from "../src/emulated-verifier/read-filter";
 
@@ -35,6 +36,12 @@ const SESSION: RegistrySession = { sessionId: "sid", privateStoreId: "PRIV" };
 const SHIM = "urn:ng-eventually:shim";
 const INBOX = "urn:ng-eventually:inbox";
 
+/** Possession, asked of the internal registry — see `polyfill.ts` on why the door
+ *  stopped publishing it. */
+function hasCap(nuri: Nuri): boolean {
+  return getCaps().capFor(nuri) !== undefined;
+}
+
 interface Quad { g: string; s: string; p: string; o: string }
 
 /** Reverse of the lib's escapeLiteral: single left-to-right pass over `\x`. */
@@ -247,21 +254,30 @@ test("a cap deposit is absorbed, not surfaced as a consumer deposit", async () =
   expect(hasCap(doc)).toBe(true); // …but it landed in bob's held caps
 });
 
-// (b) A bare reference grants nothing; the repo link of a published document does.
-test("(b) a bare reference reads nothing; the repo link of a published document opens it", async () => {
+// (b) The ORM read filter is PURE POSSESSION — it asks nothing of anyone.
+//
+// Note what this does NOT say: that a bare reference to a public document is
+// unreadable. It is readable, through the read paths, because a public store serves
+// its cap (`emulated-verifier/public-store.ts`, and `cross-user-access.test.ts` proves
+// it). This filter sits below that: it is synchronous, it decides from what the holder
+// holds AT THAT MOMENT, and a document whose cap was never obtained is filtered out
+// whatever store it sits in. The library's own read paths ask first; the reactive ORM
+// view has no door to ask through, and that limit is recorded in `read-filter.ts`.
+test("(b) the read-filtered view decides on possession alone, with no lookup", async () => {
   inject();
   setCurrentUser("alice");
   const pub = await createEntityDoc("alice", "public");
   const items = [item(pub, "u1")];
   expect(getCaps().isInPublicStore(pub)).toBe(true);
-  const link = getCaps().capFor(pub)!;
+  const cap = getCaps().capFor(pub)!;
 
-  // bob HAS the document's bare NURI (it is right there in `items`) and reads nothing.
+  // bob HAS the document's bare NURI (it is right there in `items`), holds no cap for
+  // it, and the view drops it — no question asked of any store.
   setCurrentUser("bob");
   expect(view(items)).toEqual([]);
 
-  // Receiving the repo link — what a discovery entry actually carries — opens it.
-  getCaps().learn(link);
+  // Once the cap IS among what he holds — however it got there — the same view yields it.
+  getCaps().learn(cap);
   expect(view(items)).toEqual(["u1"]);
 });