@serfab/cadre-core 0.9.0 → 0.11.0

package/dist/relay-reservation.js

@@ -0,0 +1,613 @@
+/**
+ * Relay reservation for nodes that reserve through the SEARCH listen addr — the
+ * dial, the explicit reservation request, the retry loop that keeps it, and the
+ * (live) status derivation.
+ *
+ * `@libp2p/circuit-relay-v2`'s listener branches on the SHAPE of the listen
+ * address, and the two shapes are alternatives, not layers:
+ *
+ * | listen addr                                       | libp2p behaviour                                                                     | unreachable relay          |
+ * | ------------------------------------------------- | ------------------------------------------------------------------------------------ | -------------------------- |
+ * | `<dial addr>/p2p/<relayPeerId>/p2p-circuit`        | CONFIGURED reservation: dial that exact relay and reserve, or fail                     | `listen()` throws          |
+ * | bare `/p2p-circuit`                                | SEARCH mode: register a pending reservation, to be filled by relay discovery           | nothing throws, no reserve |
+ *
+ * The configured shape is what `relay-addrs.ts` builds out of `network.relayAddrs`.
+ * It is **fail-fast by construction**: libp2p's transport manager throws
+ * `UnsupportedListenAddressesError` when any configured listen address fails to
+ * listen under the default `FATAL_ALL` fault tolerance, so naming a relay that is
+ * down means the node does not start. Good for a server; wrong for a browser tab,
+ * which must still boot (solo, undialable) when its relay is down.
+ *
+ * So a browser-shaped node listens on bare `/p2p-circuit` and needs someone to
+ * (a) dial the relay and (b) fill the pending reservation that listener created,
+ * then report whether one actually landed. That is this module. It is **fail-soft
+ * by construction**: nothing here throws.
+ *
+ * Do NOT "consolidate" the two by also setting `network.relayAddrs` on a node
+ * that reserves this way — that re-introduces the fatal configured listener
+ * alongside the search listener and the tab stops booting when the relay is down.
+ *
+ * ⚠️ WHY THE RESERVATION IS REQUESTED EXPLICITLY RATHER THAN LEFT TO DISCOVERY.
+ * libp2p fills a search listener's pending reservation from `RelayDiscovery`,
+ * which nominates a peer only once it can see the relay-hop protocol id in that
+ * peer's PEER-STORE protocol list — and that list is written exclusively by the
+ * IDENTIFY handshake. `@optimystic/db-p2p` gives every cadre node a
+ * network-namespaced identify protocol id (`/optimystic/control-<partyId>/id/1.0.0`)
+ * while the relay `ops/docker/libp2p-infra` deploys runs stock identify
+ * (`/ipfs/id/1.0.0`), so the two never identify each other, the peer store stays
+ * empty of protocols, and discovery never nominates the relay. The TCP/WebSocket
+ * connection itself is fine, which is why leaving it to discovery surfaced as a
+ * generic timeout.
+ *
+ * Identify is incidental to relaying, though: the reservation
+ * (`/libp2p/circuit/relay/0.2.0/hop`), a third peer's CONNECT through the relay,
+ * and the STOP handler on this node all use STOCK, un-namespaced protocol ids the
+ * deployed relay already serves. Discovery's only job is to GUESS which connected
+ * peer is a relay, and this module does not need to guess — it was handed the
+ * relay's address. So it asks the relay for a slot directly, via the
+ * circuit-relay transport's own reservation store.
+ *
+ * Status is derived from the node's LIVE multiaddrs on every read rather than
+ * cached at drive time: when a relay restarts or the connection drops, libp2p's
+ * listener clears its listening addrs and the circuit multiaddr disappears, so a
+ * cached snapshot would keep claiming `reserved` for a node nothing can dial.
+ *
+ * And because discovery is out of reach, nothing would ever ASK again either —
+ * so {@link driveRelayReservation} stays a single-shot primitive and
+ * {@link superviseRelayReservation} owns the retry cadence on top of it. That
+ * loop is what makes a lost reservation recover without a page reload.
+ */
+import debug from 'debug';
+import { multiaddr } from '@multiformats/multiaddr';
+import { peerIdFromString } from '@libp2p/peer-id';
+import { trailingPeerId } from './peer-record.js';
+const log = debug('sereus:cadre:relay-reservation');
+/** How long {@link driveRelayReservation} waits for a reservation to appear. */
+export const DEFAULT_RELAY_RESERVE_TIMEOUT_MS = 10000;
+export const DEFAULT_RELAY_RESERVE_POLL_MS = 250;
+/**
+ * The node's `/p2p-circuit` multiaddrs — the addresses a peer can dial it at
+ * while it holds a relay reservation. Empty means "not dialable via a relay
+ * right now", which is exactly what makes {@link resolveRelayReservationState}
+ * live rather than a stale snapshot.
+ */
+export function circuitMultiaddrs(node) {
+    return node
+        .getMultiaddrs()
+        .map((ma) => ma.toString())
+        .filter((addr) => addr.includes('/p2p-circuit'));
+}
+/**
+ * The running node's circuit-relay transport, or `null` when it has none.
+ *
+ * There is no public libp2p API for "reserve on THIS specific relay", so this
+ * reaches through `node.components.transportManager` — libp2p's internal layout.
+ * That coupling is deliberate and bounded: every step is optional-chained and the
+ * whole thing returns `null` rather than throwing, and a spec pins the seam so a
+ * libp2p upgrade that moves it fails loudly instead of silently reverting this
+ * module to the discovery wait that never fires.
+ */
+export function findCircuitRelayTransport(node) {
+    for (const transport of nodeTransports(node)) {
+        const store = transport.reservationStore;
+        if (isReservationStore(store)) {
+            return { reservationStore: store };
+        }
+    }
+    return null;
+}
+function nodeTransports(node) {
+    const manager = node.components?.transportManager;
+    if (typeof manager?.getTransports !== 'function') {
+        log('No transportManager.getTransports() on this node — libp2p internals moved?');
+        return [];
+    }
+    try {
+        return manager.getTransports();
+    }
+    catch (err) {
+        log('transportManager.getTransports() threw: %o', err);
+        return [];
+    }
+}
+function isReservationStore(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    const store = value;
+    return typeof store.addRelay === 'function' && typeof store.hasReservation === 'function';
+}
+/** Sentinel resolved by the deadline race in {@link requestOneReservation}. */
+const DEADLINE_PASSED = Symbol('relay-reservation-deadline-passed');
+/**
+ * Dial every relay in `addrs`, ask the first one that answers for a reservation
+ * slot, then wait until a `/p2p-circuit` address appears.
+ *
+ * Never throws — a dial rejection, a rejected reservation, a MALFORMED address,
+ * or a timeout all come back as an `error` string. A dial that throws does NOT
+ * cost the rest of the list: one dead relay among two must not cost the
+ * reservation on the live one, so every addr is dialed and the first error (in
+ * list order) is kept. A reservation that lands wins over any earlier error
+ * (`error: null`).
+ *
+ * `timeoutMs` bounds the WHOLE drive — dials, reservation requests and the wait
+ * share one deadline.
+ */
+export async function driveRelayReservation(node, addrs, opts) {
+    if (addrs.length === 0) {
+        return { error: null };
+    }
+    const timeoutMs = opts?.timeoutMs ?? DEFAULT_RELAY_RESERVE_TIMEOUT_MS;
+    // Clamped: a caller-supplied 0 would spin the poll loop hot until the deadline.
+    const pollMs = Math.max(1, opts?.pollMs ?? DEFAULT_RELAY_RESERVE_POLL_MS);
+    const deadline = Date.now() + timeoutMs;
+    const { connected, error: dialError } = await dialRelays(node, addrs, deadline);
+    const attempt = await requestReservation(node, connected, deadline);
+    // NOTE: a REJECTED reservation still spends the rest of the deadline polling,
+    // because discovery may independently land one (only the no-transport case is
+    // `fatal`). So a misconfigured node reports its now-legible reason a full
+    // `timeoutMs` late. If startup latency on that path ever matters, shorten the
+    // wait once every connected relay has rejected — do not skip it outright.
+    if (!attempt.fatal && (await waitForCircuitReservation(node, deadline, pollMs))) {
+        return { error: null };
+    }
+    return {
+        error: attempt.error ?? dialError ?? `no circuit reservation within ${timeoutMs}ms`
+    };
+}
+/**
+ * Dial every relay CONCURRENTLY under the drive's shared deadline. Reports the
+ * relays that answered (in list order, for the reservation step) and the first
+ * failure in LIST order (`null` when every dial connected).
+ *
+ * Concurrent and deadline-bound because this whole drive is awaited on a browser
+ * tab's startup path: dialing serially with libp2p's own (much longer) per-dial
+ * timeout meant N unreachable relays cost N dial timeouts before the reservation
+ * request even began, so `timeoutMs` bounded only the tail of the operation.
+ *
+ * Aborting a dial at the deadline is not a lost reservation — the steps that
+ * follow have no time left either, so the drive would report `error` regardless.
+ */
+async function dialRelays(node, addrs, deadline) {
+    // An explicit controller, not `AbortSignal.timeout` — the latter is not
+    // reliably present on React Native/Hermes, which runs this same module.
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), Math.max(0, deadline - Date.now()));
+    try {
+        const results = await Promise.allSettled(addrs.map((addr) => dialOne(node, addr, controller.signal)));
+        return { connected: connectedRelays(addrs, results), error: firstDialError(addrs, results) };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/**
+ * One dial, with the address PARSED INSIDE the promise.
+ *
+ * `multiaddr()` throws SYNCHRONOUSLY on a malformed string, and a throw out of
+ * the `map` callback escapes `Promise.allSettled` altogether — it would reject
+ * the whole drive (breaking the never-throws contract) and discard the dials to
+ * the other, perfectly good, addrs. `async` demotes it to a settled rejection,
+ * which is already exactly how a dial failure is reported.
+ */
+async function dialOne(node, addr, signal) {
+    return node.dial(multiaddr(addr), { signal });
+}
+function connectedRelays(addrs, results) {
+    const connected = [];
+    results.forEach((result, index) => {
+        if (result.status !== 'fulfilled')
+            return;
+        connected.push({ addr: addrs[index], peerId: result.value.remotePeer });
+    });
+    return connected;
+}
+/** Log every dial rejection; return the first one in list order. */
+function firstDialError(addrs, results) {
+    let first = null;
+    results.forEach((result, index) => {
+        if (result.status !== 'rejected')
+            return;
+        const message = result.reason instanceof Error ? result.reason.message : String(result.reason);
+        log('Relay dial failed (%s): %s', addrs[index], message);
+        first ?? (first = message);
+    });
+    return first;
+}
+/**
+ * Ask the connected relays, in list order, for a reservation slot; stop at the
+ * first success.
+ *
+ * `'discovered'`, not `'configured'`: the search listener's
+ * `relay:created-reservation` handler ignores `configured` reservations outright,
+ * so the `/p2p-circuit` listen address would never be published and
+ * `getMultiaddrs()` would stay empty even though the reservation succeeded.
+ * `'discovered'` consumes the pending-reservation id the bare `/p2p-circuit`
+ * listener registered, which is exactly what that handler matches on.
+ *
+ * Sequential, not concurrent: a bare `/p2p-circuit` listener registers exactly
+ * ONE pending reservation, so a second concurrent `addRelay` would be rejected
+ * with `HadEnoughRelaysError` — noise, not a failure. Running discovery is not a
+ * conflict either; `addRelay` dedupes through its own peer queue, so a relay that
+ * genuinely is discoverable still reserves exactly once.
+ */
+async function requestReservation(node, connected, deadline) {
+    if (connected.length === 0) {
+        // Nothing answered — the dial error is the whole story.
+        return { error: null, fatal: false };
+    }
+    const transport = findCircuitRelayTransport(node);
+    if (transport === null) {
+        return {
+            error: 'node has no circuit-relay transport — add circuitRelayTransport() to its transports',
+            fatal: true
+        };
+    }
+    let firstError = null;
+    for (const relay of connected) {
+        if (transport.reservationStore.hasReservation(relay.peerId)) {
+            return { error: null, fatal: false };
+        }
+        if (Date.now() >= deadline) {
+            break;
+        }
+        const failure = await requestOneReservation(transport.reservationStore, relay, deadline);
+        if (failure === null) {
+            return { error: null, fatal: false };
+        }
+        firstError ?? (firstError = failure);
+    }
+    return { error: firstError, fatal: false };
+}
+/**
+ * One `addRelay` call, bounded by the drive's deadline. Returns `null` on
+ * success, or the reason it failed.
+ *
+ * Deadline-raced because `addRelay` runs on libp2p's own (much longer) reservation
+ * timeout and takes no signal: without the race a drive given 1.5 s would sit on a
+ * silent relay for libp2p's timeout instead. The abandoned promise stays handled —
+ * `Promise.race` attaches its own handlers — so a later rejection is not unhandled.
+ */
+async function requestOneReservation(store, relay, deadline) {
+    let timer;
+    const expired = new Promise((resolve) => {
+        timer = setTimeout(() => resolve(DEADLINE_PASSED), Math.max(0, deadline - Date.now()));
+    });
+    try {
+        const outcome = await Promise.race([store.addRelay(relay.peerId, 'discovered'), expired]);
+        if (outcome === DEADLINE_PASSED) {
+            log('Relay reservation request (%s) still pending at the deadline', relay.addr);
+            return `relay reservation request to ${relay.addr} did not complete before the deadline`;
+        }
+        return null;
+    }
+    catch (err) {
+        const message = describeReservationFailure(err, relay.addr);
+        log('Relay reservation failed (%s): %s', relay.addr, message);
+        return message;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/**
+ * Turn libp2p's reservation rejection into a reason that names the actual cause.
+ *
+ * `HadEnoughRelaysError` needs translating rather than passing through: its own
+ * message ("we do not need any more relays") says the opposite of what happened.
+ * A `'discovered'` reservation is refused when the node holds NO pending
+ * reservation id, and a node holds one only while it listens on the bare
+ * `/p2p-circuit` search address — so the real cause is a missing listen address.
+ */
+function describeReservationFailure(err, addr) {
+    // NOTE: libp2p adds a peer to the reservation store's `relayFilter` when a
+    // request fails with `DialError` or `UnsupportedProtocolError`, and the failure
+    // path does not reset that filter (it only resets when a reservation is actually
+    // removed). So a SECOND drive against the same relay in the same process reports
+    // `ListenError: The relay was previously invalid` even if the relay has since
+    // recovered. `RelayReservationLoop` clears the entry before every attempt (see
+    // {@link clearRelayFilterEntry}); a caller that re-drives WITHOUT the supervisor
+    // still has to deal with the filter itself.
+    const name = err instanceof Error ? err.name : '';
+    const message = err instanceof Error ? err.message : String(err);
+    switch (name) {
+        case 'HadEnoughRelaysError':
+            return `relay reservation on ${addr} was not requested: this node holds no pending circuit reservation — it is not listening on the bare /p2p-circuit address`;
+        case 'UnsupportedProtocolError':
+            return `peer at ${addr} does not speak the circuit-relay hop protocol — it is not a relay`;
+        default:
+            return `relay reservation on ${addr} failed: ${message}`;
+    }
+}
+/**
+ * Poll until the node advertises a `/p2p-circuit` address, or the deadline passes.
+ *
+ * Still a poll even though the reservation is now requested explicitly: `addRelay`
+ * resolving means the RELAY accepted, while the listen address is published a tick
+ * later by the listener's `relay:created-reservation` handler, and a reservation
+ * that discovery lands independently has no return value to await at all.
+ *
+ * NOTE: polls rather than subscribing to libp2p's `self:peer:update` — it keeps
+ * this free of libp2p event-name coupling. If 250 ms of reservation latency ever
+ * matters, switch to the event and keep the poll as a fallback.
+ */
+async function waitForCircuitReservation(node, deadline, pollMs) {
+    for (;;) {
+        if (circuitMultiaddrs(node).length > 0) {
+            return true;
+        }
+        if (Date.now() >= deadline) {
+            return false;
+        }
+        await delay(Math.min(pollMs, Math.max(0, deadline - Date.now())));
+    }
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/** Gap between liveness checks while a reservation is held. */
+export const DEFAULT_RELAY_CHECK_MS = 5000;
+/** Backoff before the first re-drive after a failed attempt. */
+export const DEFAULT_RELAY_MIN_BACKOFF_MS = 2000;
+/** Ceiling the backoff doubles up to. */
+export const DEFAULT_RELAY_MAX_BACKOFF_MS = 60000;
+/**
+ * Keep asking for a relay reservation until one is held, then keep watching that
+ * it still is — the thing that makes a lost reservation recover on its own.
+ *
+ * Needed because nothing else re-drives: libp2p re-fills a search listener's
+ * freed slot from relay DISCOVERY, and a cadre node's namespaced identify puts
+ * discovery permanently out of reach (see the module header). Without this loop a
+ * relay restart left a browser tab undialable until the user reloaded the page.
+ *
+ * Per tick:
+ *  - a reservation is held → reset the backoff, clear the error, re-check in
+ *    `checkMs`. No drive: a healthy node must not re-request every few seconds.
+ *  - otherwise → un-poison the reservation store's relay filter (see
+ *    {@link clearRelayFilterEntry}) and run ONE {@link driveRelayReservation}.
+ *    If that lands a reservation, rejoin the healthy path above; if not, sleep
+ *    the current backoff and double it up to `maxBackoffMs`.
+ *
+ * Starts immediately; the first tick runs before this returns.
+ */
+export function superviseRelayReservation(node, addrs, opts) {
+    return new RelayReservationLoop(node, [...addrs], opts ?? {});
+}
+/**
+ * Forget that `addr`'s peer ever failed a reservation request, so the next
+ * attempt is actually made rather than refused out of hand.
+ *
+ * `ReservationStore` records a peer in `relayFilter` when its reservation request
+ * fails with `DialError` or `UnsupportedProtocolError`, and NOTHING on that path
+ * ever clears it: the reset lives in `#checkReservationCount`, which only runs
+ * when a reservation is genuinely removed, and `#removeReservation` early-returns
+ * when there was never one. So a relay that was briefly not-a-relay (or died
+ * between our dial and the hop request) stays permanently rejected with
+ * `The relay was previously invalid` — measured, not inferred.
+ *
+ * Fails soft in every direction: no `relayFilter`, no `remove`, an addr with no
+ * peer id, a malformed addr — all mean "no un-poisoning", never a throw. The
+ * retry loop still recovers the common case without this, because a relay that is
+ * simply DOWN fails our own dial first and never reaches the filter.
+ *
+ * Returns whether an entry was actually removed (for specs; callers ignore it).
+ */
+export function clearRelayFilterEntry(store, addr) {
+    const filter = store.relayFilter;
+    if (typeof filter?.remove !== 'function') {
+        log('Reservation store has no removable relayFilter — cannot un-poison %s', addr);
+        return false;
+    }
+    try {
+        // The peer id is in the multiaddr, so this costs no dial and can run before one.
+        const peerId = trailingPeerId(multiaddr(addr));
+        if (peerId === null) {
+            // NOTE: an addr with no `/p2p/` component can still be dialed and reserved
+            // through (the peer id comes off the connection), but it can never be
+            // un-poisoned — so for THAT addr a poisoned filter is permanent again. No
+            // caller supplies such an addr today; if one ever does, resolve the peer id
+            // from the live connection instead of the multiaddr.
+            return false;
+        }
+        return filter.remove(peerIdFromString(peerId).toMultihash().bytes);
+    }
+    catch (err) {
+        log('Could not clear the relayFilter entry for %s: %o', addr, err);
+        return false;
+    }
+}
+/** The self-rescheduling loop behind {@link superviseRelayReservation}. */
+class RelayReservationLoop {
+    constructor(node, addrs, opts) {
+        this.node = node;
+        this.addrs = addrs;
+        this.opts = opts;
+        this.timer = null;
+        this.stopped = false;
+        this.inFlight = false;
+        this.nextTickAtMs = null;
+        this.failure = null;
+        this.settleFirstAttempt = () => { };
+        this.firstAttemptSettled = false;
+        // Clamped away from 0: a caller-supplied 0 would spin the loop hot.
+        this.checkMs = Math.max(1, opts.checkMs ?? DEFAULT_RELAY_CHECK_MS);
+        this.minBackoffMs = Math.max(1, opts.minBackoffMs ?? DEFAULT_RELAY_MIN_BACKOFF_MS);
+        this.maxBackoffMs = Math.max(this.minBackoffMs, opts.maxBackoffMs ?? DEFAULT_RELAY_MAX_BACKOFF_MS);
+        this.backoffMs = this.minBackoffMs;
+        this.firstAttempt = new Promise((resolve) => {
+            this.settleFirstAttempt = resolve;
+        });
+        void this.tick();
+    }
+    get driving() {
+        return this.inFlight;
+    }
+    get retryAtMs() {
+        return this.nextTickAtMs;
+    }
+    get lastError() {
+        return this.failure;
+    }
+    stop() {
+        if (this.stopped) {
+            return;
+        }
+        this.stopped = true;
+        if (this.timer !== null) {
+            clearTimeout(this.timer);
+            this.timer = null;
+        }
+        this.nextTickAtMs = null;
+        this.settleFirst();
+    }
+    async tick() {
+        if (this.stopped) {
+            return;
+        }
+        this.nextTickAtMs = null;
+        if (this.reservationHeld()) {
+            this.onReservationHeld();
+            return;
+        }
+        await this.driveOnce();
+        if (this.stopped) {
+            return;
+        }
+        this.settleFirst();
+        // A drive that LANDED a reservation resumes the healthy cadence immediately.
+        // Backing off here instead would leave the first liveness check after a long
+        // outage a fully grown backoff away (up to `maxBackoffMs`), so a reservation
+        // lost again right after recovery would go unnoticed for that whole window.
+        if (this.reservationHeld()) {
+            this.onReservationHeld();
+            return;
+        }
+        this.scheduleBackoff();
+    }
+    reservationHeld() {
+        return circuitMultiaddrs(this.node).length > 0;
+    }
+    /** Healthy tick: nothing to request, so only reset and re-check later. */
+    onReservationHeld() {
+        this.backoffMs = this.minBackoffMs;
+        this.failure = null;
+        this.settleFirst();
+        this.schedule(this.checkMs);
+    }
+    async driveOnce() {
+        this.inFlight = true;
+        try {
+            this.unpoisonRelayFilter();
+            const { error } = await driveRelayReservation(this.node, this.addrs, this.opts);
+            if (!this.stopped) {
+                this.failure = error;
+            }
+        }
+        catch (err) {
+            // `driveRelayReservation` is fail-soft by contract, so reaching here means
+            // that contract broke. The loop must survive it anyway: an escaping
+            // rejection would leave `firstAttempt` pending FOREVER (hanging every
+            // caller that awaits a reservation at startup) and schedule no further
+            // attempt, which is the failure this whole supervisor exists to prevent.
+            const message = err instanceof Error ? err.message : String(err);
+            log('Relay reservation drive threw, which it should not: %s', message);
+            if (!this.stopped) {
+                this.failure = message;
+            }
+        }
+        finally {
+            this.inFlight = false;
+        }
+    }
+    scheduleBackoff() {
+        const wait = this.backoffMs;
+        this.backoffMs = Math.min(this.backoffMs * 2, this.maxBackoffMs);
+        this.schedule(wait);
+    }
+    unpoisonRelayFilter() {
+        const transport = findCircuitRelayTransport(this.node);
+        if (transport === null) {
+            return;
+        }
+        for (const addr of this.addrs) {
+            clearRelayFilterEntry(transport.reservationStore, addr);
+        }
+    }
+    schedule(ms) {
+        if (this.stopped) {
+            return;
+        }
+        this.nextTickAtMs = Date.now() + ms;
+        this.timer = setTimeout(() => {
+            this.timer = null;
+            void this.tick();
+        }, ms);
+        // Node keeps the process alive while a timer is pending, so an un-unref'd
+        // supervisor would hang every CLI run and vitest worker that ever reserved.
+        // Cast + optional-chain: browsers and React Native have no `unref`.
+        this.timer.unref?.();
+    }
+    settleFirst() {
+        if (this.firstAttemptSettled) {
+            return;
+        }
+        this.firstAttemptSettled = true;
+        this.settleFirstAttempt();
+    }
+}
+/**
+ * Derive the reservation posture, reading the node's circuit addrs LIVE. Pure
+ * apart from that read, so the precedence is testable on its own:
+ *
+ * | condition                | status                                          |
+ * | ------------------------ | ----------------------------------------------- |
+ * | no addrs supplied        | `none`                                          |
+ * | live circuit addrs held  | `reserved` (`error: null`)                      |
+ * | a drive is in flight     | `dialing`                                       |
+ * | a retry is scheduled     | `retrying`                                      |
+ * | otherwise                | `error`                                         |
+ *
+ * `reserved` is checked BEFORE `error` on purpose: the circuit addrs are read
+ * live, so a reservation that lands by ANY route supersedes a stale error string
+ * without a second drive.
+ *
+ * `retrying` sits between the two so that `error` carries a sharper meaning:
+ * NOBODY IS GOING TO TRY AGAIN. A lost reservation does come back on its own now,
+ * as long as a {@link RelayReservationSupervisor} is running — that loop is the
+ * only thing that re-drives, since libp2p re-fills a search listener's freed slot
+ * from relay DISCOVERY, which a cadre node's namespaced identify puts permanently
+ * out of reach (see the module header). So `error` means the supervisor was
+ * stopped, was never started, or there is no node at all.
+ *
+ * `retryAtMs` is the supervisor's next scheduled tick (`null` while a drive runs
+ * or when there is no supervisor); it both selects `retrying` and is passed
+ * through so a UI can count down to the next attempt.
+ */
+export function resolveRelayReservationState(node, addrs, lastError, driving, retryAtMs) {
+    if (addrs.length === 0) {
+        return { status: 'none', addrs: [], circuitAddrs: [], error: null, retryAtMs: null };
+    }
+    const supplied = [...addrs];
+    const circuitAddrs = node ? circuitMultiaddrs(node) : [];
+    if (circuitAddrs.length > 0) {
+        return { status: 'reserved', addrs: supplied, circuitAddrs, error: null, retryAtMs };
+    }
+    if (driving) {
+        return {
+            status: 'dialing',
+            addrs: supplied,
+            circuitAddrs: [],
+            error: lastError,
+            retryAtMs: null
+        };
+    }
+    // `driveRelayReservation` always reports a reason when it finishes without a
+    // reservation, so `lastError` is normally set below. The fallback only covers
+    // addrs recorded without a completed drive.
+    const error = lastError ?? 'no circuit reservation held';
+    if (retryAtMs !== null) {
+        return { status: 'retrying', addrs: supplied, circuitAddrs: [], error, retryAtMs };
+    }
+    return { status: 'error', addrs: supplied, circuitAddrs: [], error, retryAtMs: null };
+}
+//# sourceMappingURL=relay-reservation.js.map

package/dist/relay-reservation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"relay-reservation.js","sourceRoot":"","sources":["../src/relay-reservation.ts"],"names":[],"mappings":"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"}