feat(access-gate): le parcours de connexion passe dans le polyfill

Chaque étape de cet écran n'existe que parce qu'un wallet héberge plusieurs
identités. Une app qui l'implémente écrit du code qu'elle devra supprimer, et
pire, du code qui enseigne à ses auteurs un modèle que NextGraph n'a pas :
« je nomme mon identité ». Le premier consommateur en avait ~300 lignes — un
gate, un écran, un module wallet, un contexte d'identité, trois features. C'est
le travail de la bibliothèque, pas le sien.

`ensureIdentity()` : un appel, avant que l'app s'affiche. Il ne prend PAS
d'identifiant — nommer une identité est l'étape qui disparaîtra, donc elle ne
doit pas figurer dans la signature. Le jour où le wallet fournit l'identité,
l'appel se résout sans rien afficher et le code de l'appelant ne bouge pas.

L'écran est en DOM natif, sous shadow root : c'est une barrière technique
montrée avant qu'une application s'affiche, comme une demande de mot de passe
sur une bêta fermée. La lier à un framework obligerait chaque consommateur à
adopter ce framework pour un écran voué à disparaître.

L'ordre de résolution de l'identité est pinné par des tests, parce que s'y
tromper échoue en SILENCE : le parcours traverse deux partitions localStorage
distinctes — la page et l'iframe du broker — et seul l'URL franchit la
frontière. Si le stockage l'emportait, l'iframe lirait une identité vide,
provisionnerait un second utilisateur virtuel, et l'utilisateur reviendrait dans
un espace vide sans la moindre erreur.

Les identifiants du wallet partagé (fichier, mot de passe) passent par
`configure()` : ce sont des données de déploiement, et cet appel est déjà celui
qui devient inerte à la migration. Au passage, l'ancien champ `sharedWallet:
{ name, secret }` — inutilisé nulle part — est remplacé.

168 tests unitaires, typecheck vert.

packages/client/test/access-gate.test.ts

@@ -0,0 +1,94 @@
+/**
+ * The access gate's identity resolution.
+ *
+ * This is the piece whose failure is SILENT: get the order wrong and the broker iframe
+ * reads an empty identity, provisions a second virtual user, and the returning user
+ * lands in an empty space with no error anywhere. So the order is pinned, not trusted.
+ */
+import { test, expect, afterEach } from "bun:test";
+import { configure, resetConfig, setCurrentUser, getCurrentUser } from "../src/polyfill";
+import { ensureIdentity } from "../src/shared-wallet/access-gate";
+
+const KEY = "ng-eventually:identity";
+
+/** A localStorage double — the real one is absent in `bun test`. */
+function fakeStorage(initial: Record<string, string> = {}) {
+  const map = new Map(Object.entries(initial));
+  return {
+    getItem: (k: string) => map.get(k) ?? null,
+    setItem: (k: string, v: string) => void map.set(k, v),
+    removeItem: (k: string) => void map.delete(k),
+    get size() { return map.size; },
+  };
+}
+
+/** Put the page in a given URL + storage state, as the browser would. */
+function inPage(search: string, storage: ReturnType<typeof fakeStorage>) {
+  (globalThis as any).location = { search, href: "https://app.example" + search };
+  (globalThis as any).localStorage = storage;
+  (globalThis as any).history = { replaceState: () => {} };
+}
+
+afterEach(() => {
+  setCurrentUser(null);
+  resetConfig();
+  delete (globalThis as any).location;
+  delete (globalThis as any).localStorage;
+  delete (globalThis as any).history;
+});
+
+function configured() {
+  configure({
+    ng: {} as never,
+    useShape: (() => {}) as never,
+    sharedWallet: { fileUrl: "/w.ngw", password: "pw" },
+  });
+}
+
+test("an identity already set is left alone — the gate never re-asks", async () => {
+  configured();
+  inPage("", fakeStorage());
+  setCurrentUser("alice");
+  await ensureIdentity();
+  expect(getCurrentUser()).toBe("alice");
+});
+
+test("the URL parameter WINS over storage — it is the only thing that crosses the frontier", async () => {
+  // The top-level page and the broker iframe have separate localStorage partitions, so a
+  // value written on one side is not the value the other reads. The URL survives the
+  // round-trip; storage does not. If storage won here, a user entering a second
+  // identifier would keep being sent back to the first one's space.
+  configured();
+  inPage("?ng-id=fromurl", fakeStorage({ [KEY]: "fromstorage" }));
+  await ensureIdentity();
+  expect(getCurrentUser()).toBe("fromurl");
+});
+
+test("the URL parameter is copied into THIS partition, so a plain reload still knows", async () => {
+  configured();
+  const storage = fakeStorage();
+  inPage("?ng-id=carol", storage);
+  await ensureIdentity();
+  expect(storage.getItem(KEY)).toBe("carol");
+});
+
+test("with no parameter, storage answers — a reload does not re-ask", async () => {
+  configured();
+  inPage("", fakeStorage({ [KEY]: "dana" }));
+  await ensureIdentity();
+  expect(getCurrentUser()).toBe("dana");
+});
+
+test("nothing known and no DOM to ask on → it refuses loudly", async () => {
+  // Continuing silently would provision an anonymous virtual space, which is the failure
+  // this module exists to prevent. The error names what the caller must do.
+  configured();
+  inPage("", fakeStorage());
+  await expect(ensureIdentity()).rejects.toThrow(/no DOM to ask on/i);
+});
+
+test("no shared wallet configured → it refuses, rather than inventing a space", async () => {
+  configure({ ng: {} as never, useShape: (() => {}) as never });
+  inPage("", fakeStorage());
+  await expect(ensureIdentity()).rejects.toThrow(/no shared wallet configured/i);
+});