feat!: le paquet crée un index et lui ajoute une référence, rien de plus

e2e/bridge.ts

@@ -14,13 +14,27 @@
  * ends up typed as a reference.
  */
 
-import type { IndexEntry, UnionSubject } from "../src/index";
+import type { UnionSubject } from "@ng-eventually/polyfill";
+
+/**
+ * One entry, as THIS APPLICATION decodes one out of the index document.
+ *
+ * It is declared here and not imported, because `@ng-helpers/indexing` publishes no
+ * such type and no call that produces one: an index is an ordinary document, so its
+ * contents are whatever `readUnion` hands back, read with the two published IRIs.
+ * A subject carrying several values shows up as several rows — the document's own
+ * truth, and the application's business to make something of.
+ */
+export interface IndexRow {
+  readonly object: string;
+  readonly value: string;
+}
 
 /** What the leak probe observed — see `run.ts`'s last journey. */
 export interface BrokenInboxOutcome {
-  /** The message `createIndex` rejected with, or `null` if it did not reject. */
+  /** The message `create` rejected with, or `null` if it did not reject. */
   readonly rejected: string | null;
-  /** What `createIndex` returned, on the impossible branch where it did not reject. */
+  /** What `create` returned, on the impossible branch where it did not reject. */
   readonly returned: string | null;
   /** The documents that appeared in this identity's public store despite the failure. */
   readonly appeared: readonly string[];
@@ -75,20 +89,25 @@ export interface IndexingBridge {
   /** Publish a public document carrying one value for one predicate. */
   publishObject(predicate: string, value: string): Promise<string>;
   /** Hand the CONFIGURED index a reference to an object. Anyone may. */
-  referConfigured(object: string): Promise<void>;
+  addToConfigured(object: string): Promise<void>;
   /** Hand a NAMED index a reference — used where no identity boundary is crossed. */
-  referTo(index: string, object: string): Promise<void>;
+  addTo(index: string, object: string): Promise<void>;
   /**
-   * Connect again — obtain a fresh `Indexing` handle, which is what a page load does.
+   * Obtain a fresh `Indexing` handle, which is what a page load does.
    *
-   * There is no curating act to drive: an index is curated at its creator's next
-   * connection and on each deposit while the creator is connected. This is the first
-   * of the two, driven deliberately so a journey has a point at which the catching
-   * up is over; the second needs nothing from anyone.
+   * It reaches NOTHING — a handle is a session id and two acts, and building one talks
+   * to nobody. That is precisely what one journey asserts: taking a handle again changes
+   * nothing an index holds. It is NOT a settle point and cannot be used as one; what a
+   * journey waits on after a deposit is the INDEX, read like any other document (`run.ts`,
+   * `settled`).
    */
-  reconnect(): Promise<void>;
-  /** The index's entries, ordered by value. */
-  read(index: string): Promise<IndexEntry[]>;
+  rebuildHandle(): Promise<void>;
+  /**
+   * The index's entries, ordered by value — decoded BY THIS APPLICATION, out of an
+   * ordinary `readUnion` of the index document, with nothing from the library but the
+   * two IRIs it publishes. That the suite can do this at all is the claim under test.
+   */
+  read(index: string): Promise<IndexRow[]>;
 
   /** What a document literally holds, straight off `readUnion` — the write-form probe. */
   readRaw(doc: string): Promise<UnionSubject[]>;
@@ -105,7 +124,7 @@ export interface IndexingBridge {
   listPublicDocs(): Promise<string[]>;
 
   /**
-   * `createIndex` with its inbox step made to fail — everything else real, against the
+   * `create` with its inbox step made to fail — everything else real, against the
    * real broker. Answers whether a half-created index is left behind.
    */
   createIndexWithBrokenInbox(field: string): Promise<BrokenInboxOutcome>;