Reconnexion/ng-eventually
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix: dire le pari comme un pari, et distinguer deux manques d'inbox que rien ne distinguait

Browse Source
This commit is contained in:
Sylvain Duchesne
2026-08-20 10:47:39 +02:00
parent c507e79f8a
commit 6a99585efc
6 changed files with 370 additions and 41 deletions
Download Patch File Download Diff File Expand all files Collapse all files
packages/polyfill/src/emulated-verifier/branch-registers.ts
+23 -4
View File
@@ -502,10 +502,29 @@ export async function myInboxes(): Promise<Nuri[]> {
export interface InboxEnumeration {
/** Every inbox this holder may read that COULD be listed — possibly not all of them. */
inboxes: Nuri[];
/** What stopped the rest from being listed, or `null` when nothing did. */
incomplete: { error: unknown } | null;
/**
* What stopped the rest from being listed, or `null` when nothing did — and WHICH of the
* two registers stopped it, because the two shortfalls are not the same condition.
*
* `"account-record"` means the user's OWN two inboxes are missing, which is where a share
* addressed to a PERSON lands: the identity has nothing watched that a stranger can reach,
* and the document half was never even attempted (the account record is what it reads
* through). `"user-branch"` means those two are in hand and only the per-document inboxes
* are missing. Told apart because a caller that reports one of them has to be able to say
* that the OTHER one has now happened — `error` alone cannot, and the observation
* de-duplicating on "already said something" swallowed exactly that.
*/
incomplete: { error: unknown; register: InboxRegister } | null;
}
/**
* WHICH of the two registers behind {@link enumerateMyInboxes} could not be read.
*
* Named after the register, not after the failure, because that is what a reader has to go
* and look at: the account record in the doc-shim, and the User branch of the private store.
*/
export type InboxRegister = "account-record" | "user-branch";
/**
* {@link myInboxes}, for the caller that can use a PARTIAL answer — the live observation.
*
@@ -537,7 +556,7 @@ export async function enumerateMyInboxes(): Promise<InboxEnumeration> {
} catch (error) {
// The account record is what the other half reads THROUGH (`readInboxCapPairs` resolves
// the same record to find the private store), so there is no second half to attempt.
return { inboxes: out, incomplete: { error } };
return { inboxes: out, incomplete: { error, register: "account-record" } };
}
try {
for (const { inbox } of await readInboxCapPairs()) {
@@ -546,7 +565,7 @@ export async function enumerateMyInboxes(): Promise<InboxEnumeration> {
out.push(inbox);
}
} catch (error) {
return { inboxes: out, incomplete: { error } };
return { inboxes: out, incomplete: { error, register: "user-branch" } };
}
return { inboxes: out, incomplete: null };
}
packages/polyfill/src/emulated-verifier/inbox-observer.ts
+37 -9
View File
@@ -57,7 +57,7 @@
import { getCaps, getCurrentUser } from "../shared-wallet/bootstrap";
import { accessLogPrefix, logStage, shortNuri } from "../shared-wallet/access-log";
import { enumerateMyInboxes, type InboxEnumeration } from "./branch-registers";
import { enumerateMyInboxes, type InboxEnumeration, type InboxRegister } from "./branch-registers";
import { drainInboxSerially, drainsSettled } from "./inbox-drain";
import { lookupAccount } from "../shared-wallet/account-registry";
import { processInbox } from "../surface/inbox";
@@ -83,7 +83,7 @@ interface Observation {
/** A trigger that arrived mid-cycle: the running one repeats once rather than lose it. */
enumerateAgain: boolean;
/**
* True while the shortfall reported by the last enumeration is still the SAME one — so a
* WHICH shortfall was reported last, or `null` when the last list came back WHOLE — so a
* register that stays unreadable is reported once, not once per cycle.
*
* Every signal this observation listens to runs a full cycle, and a persistent shortfall
@@ -91,8 +91,17 @@ interface Observation {
* is nudged: one deposit produced three copies of the same line. That is what buries the
* report that matters under the report that repeats. Cleared the moment a list comes back
* WHOLE, so a shortfall that goes away and returns is a new occurrence and says so.
*
* ── The register, and not a bare "already said something" ─────────────────
* There are TWO shortfalls, they are disjoint, and one is far worse than the other: the
* account record failing leaves this identity with NOTHING watched, its own two inboxes
* included, while the User branch failing leaves those two watched and only the
* per-document inboxes missing ({@link InboxEnumeration.incomplete}). A boolean here made
* the second silence the first — the condition CHANGED, to a materially different one, and
* the log said nothing because something had already been said. Keyed by register, a
* change of shortfall is what it is: news.
*/
shortfallReported: boolean;
shortfallReported: InboxRegister | null;
/** Enumerations and applications in flight — what {@link observationSettled} waits on. */
pending: Set<Promise<void>>;
}
@@ -116,6 +125,22 @@ function reportUnobserved(what: string, error: unknown): void {
);
}
/**
* What a shortfall on `register` leaves unwatched, in the words the log uses.
*
* The two lines have to READ differently, not merely be counted differently: a reader who
* sees the second one after the first has to be able to tell that the condition changed, and
* two identical sentences make an escalation look like a repeat. Both keep the phrase the
* report has always ended on, because it is the one thing this line is scanned for.
*/
function shortfallSaid(register: InboxRegister): string {
return register === "account-record"
? "the inboxes to watch could not all be listed (the account record — your own two " +
"inboxes, where a share addressed to you by name lands, are NOT among the ones watched)"
: "the inboxes to watch could not all be listed (the register of the inboxes opened on " +
"documents — your own two are watched)";
}
/** Is `obs` still the live observation, for the identity it belongs to? */
function current(obs: Observation): boolean {
return observation === obs && getCurrentUser() === obs.holder;
@@ -193,7 +218,10 @@ async function applyWhatArrived(obs: Observation, inbox: Nuri): Promise<void> {
* Once per OCCURRENCE, though, not once per enumeration — see
* {@link Observation.shortfallReported}. The retry that repairs it is also what re-reads it,
* so a condition that persists is re-discovered by every signal; reporting each discovery
* says "it happened again" about the single thing that never stopped happening.
* says "it happened again" about the single thing that never stopped happening. An
* occurrence is per REGISTER, because the two shortfalls are two conditions: the list going
* from "missing the document inboxes" to "missing your own two" is not the same fault
* continuing, it is a worse one starting.
*/
async function watchTheInboxes(obs: Observation): Promise<void> {
if (!current(obs)) return;
@@ -207,10 +235,10 @@ async function watchTheInboxes(obs: Observation): Promise<void> {
}
if (!current(obs)) return;
if (listed.incomplete === null) {
obs.shortfallReported = false;
} else if (!obs.shortfallReported) {
obs.shortfallReported = true;
reportUnobserved("the inboxes to watch could not all be listed", listed.incomplete.error);
obs.shortfallReported = null;
} else if (obs.shortfallReported !== listed.incomplete.register) {
obs.shortfallReported = listed.incomplete.register;
reportUnobserved(shortfallSaid(listed.incomplete.register), listed.incomplete.error);
}
for (const inbox of listed.inboxes) {
if (obs.inboxes.has(inbox)) continue;
@@ -373,7 +401,7 @@ export async function startObservingInboxes(): Promise<void> {
holdings: null,
enumerating: false,
enumerateAgain: false,
shortfallReported: false,
shortfallReported: null,
pending: new Set(),
};
observation = obs;