@statewalker/httpeers-libp2p 0.1.3

package/dist/link.js

@@ -0,0 +1,88 @@
+/**
+ * libp2p, as a `PeerLink`.
+ *
+ * This is the whole of what makes the bridge libp2p-specific: how to open a
+ * duplex to a peer, and how to accept one. Everything the bridge does with
+ * those duplexes -- binding the proven peer, one stream per call, the permit,
+ * the timeout -- lives in `@statewalker/httpeers-bridge` and is shared with
+ * every other transport, including the MessagePort one the tests use.
+ *
+ * `serveConnections` is used rather than `node.handle` by hand because it
+ * already threads a `ConnectionContext`, and `context.remotePeer` is the
+ * answer the Noise handshake established. That value is what the bridge binds
+ * to every inbound request, and it is the reason a peer cannot lie about who
+ * it is no matter what headers it sets.
+ */
+import { peerIdFromString } from "@libp2p/peer-id";
+import { multiaddr } from "@multiformats/multiaddr";
+import { connect, serveConnections, } from "@statewalker/webrun-streams-libp2p";
+import { DEFAULT_DRAIN_TIMEOUT_MS, DEFAULT_MAX_STREAMS, PROTOCOL } from "./transport.js";
+/** Wrap a running libp2p node as the one seam the bridge needs. */
+export function libp2pLink(init) {
+    const { node, protocol = PROTOCOL, drainTimeoutMs = DEFAULT_DRAIN_TIMEOUT_MS, maxInboundStreams = DEFAULT_MAX_STREAMS, maxOutboundStreams = DEFAULT_MAX_STREAMS, serveOnLimitedConnection, callOnLimitedConnection = false, } = init;
+    return {
+        async open(peerId) {
+            // A BARE `/p2p/<id>` dial, deliberately: a peer dialled once by full
+            // multiaddr is dialable again by id alone, and composing an address here
+            // would duplicate the routing decisions `reservation.ts` already made.
+            const limited = typeof callOnLimitedConnection === "function"
+                ? callOnLimitedConnection(peerId)
+                : callOnLimitedConnection;
+            const conn = await connect({
+                node: limited ? keptCircuitFirst(node, peerId) : node,
+                peer: multiaddr(`/p2p/${peerId}`),
+                protocol,
+                drainTimeoutMs,
+                maxOutboundStreams,
+                ...(limited ? { runOnLimitedConnection: true } : {}),
+            });
+            return { call: conn.call, close: async () => await conn.close() };
+        },
+        async serve(handlerFor) {
+            return serveConnections({
+                node,
+                protocol,
+                drainTimeoutMs,
+                maxInboundStreams,
+                maxOutboundStreams,
+                runOnLimitedConnection: serveOnLimitedConnection,
+            }, (context) => handlerFor(context.remotePeer.toString()));
+        },
+    };
+}
+/**
+ * `node`, except that a stream to `peerId` opens on the LIMITED connection
+ * already held to it when that is the only kind there is. Used only for a
+ * target `callOnLimitedConnection` allows.
+ *
+ * WHY THE FLAG ALONE IS NOT ENOUGH. libp2p 3.3.8 does not reuse a limited
+ * connection for a dial: `findExistingConnection`
+ * (`connection-manager/utils.js`) returns only connections with
+ * `limits == null`, so `dialProtocol` to a peer reachable only by a kept relay
+ * circuit dials AGAIN, from the peer store -- a second circuit per call, through
+ * whichever of the relay's addresses identify taught it. The
+ * relay-fallback conformance test measured exactly that (two new connections
+ * for two requests) before this existed. The kept connection is the one the
+ * caller chose; the stream goes there.
+ *
+ * An UNLIMITED connection still wins when there is one (a WebRTC upgrade that
+ * did come up): that case is left to libp2p's own dial, which reuses it.
+ *
+ * A NARROW STAND-IN, not a wrapper: `connect` (`webrun-streams-libp2p`) reads
+ * nothing from the node but `dialProtocol`, and giving that package a way to
+ * take a `Connection` would be a change in another repository for one caller.
+ */
+function keptCircuitFirst(node, peerId) {
+    const dialer = {
+        dialProtocol: async (peer, protocols, options) => {
+            const open = node.getConnections(peerIdFromString(peerId)).filter((c) => c.status === "open");
+            const kept = open.some((c) => c.limits == null)
+                ? undefined
+                : open.find((c) => c.limits != null);
+            return kept != null
+                ? kept.newStream(protocols, options)
+                : node.dialProtocol(peer, protocols, options);
+        },
+    };
+    return dialer;
+}

package/dist/multiaddr-parts.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Reading a peer id out of a multiaddr, without `Array.prototype.findLast`.
+ *
+ * The prototype used `findLast`, which needs `lib: ES2023`. Raising this
+ * package's lib would raise the RUNTIME floor for every consumer — the emitted
+ * code calls the method regardless of what the types allow — for one line of
+ * convenience. A reverse loop costs nothing and keeps the floor at ES2022,
+ * matching every other package here.
+ *
+ * To reverse: set `"lib": ["ES2023"]` in tsconfig.json and inline
+ * `.getComponents().findLast((c) => c.name === "p2p")?.value` at the two call
+ * sites (`reservation.ts`, `hub-link.ts`).
+ *
+ * LAST, not first, and that is the whole point: a circuit address is
+ * `/…/p2p/<relay>/p2p-circuit/p2p/<target>`, so the FIRST `p2p` component is
+ * the relay and the last is whoever the address finally names. Taking the
+ * first would hang up on the relay when asked to hang up on a peer.
+ */
+import type { Multiaddr } from "@multiformats/multiaddr";
+export declare function lastPeerIdOf(addr: Multiaddr): string | undefined;
+//# sourceMappingURL=multiaddr-parts.d.ts.map

package/dist/multiaddr-parts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multiaddr-parts.d.ts","sourceRoot":"","sources":["../src/multiaddr-parts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEzD,wBAAgB,YAAY,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,GAAG,SAAS,CAOhE"}

package/dist/multiaddr-parts.js

@@ -0,0 +1,27 @@
+/**
+ * Reading a peer id out of a multiaddr, without `Array.prototype.findLast`.
+ *
+ * The prototype used `findLast`, which needs `lib: ES2023`. Raising this
+ * package's lib would raise the RUNTIME floor for every consumer — the emitted
+ * code calls the method regardless of what the types allow — for one line of
+ * convenience. A reverse loop costs nothing and keeps the floor at ES2022,
+ * matching every other package here.
+ *
+ * To reverse: set `"lib": ["ES2023"]` in tsconfig.json and inline
+ * `.getComponents().findLast((c) => c.name === "p2p")?.value` at the two call
+ * sites (`reservation.ts`, `hub-link.ts`).
+ *
+ * LAST, not first, and that is the whole point: a circuit address is
+ * `/…/p2p/<relay>/p2p-circuit/p2p/<target>`, so the FIRST `p2p` component is
+ * the relay and the last is whoever the address finally names. Taking the
+ * first would hang up on the relay when asked to hang up on a peer.
+ */
+export function lastPeerIdOf(addr) {
+    const components = addr.getComponents();
+    for (let i = components.length - 1; i >= 0; i--) {
+        const component = components[i];
+        if (component?.name === "p2p")
+            return component.value;
+    }
+    return undefined;
+}

package/dist/node.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The Node profile. Everything here is why the root export is not this.
+ *
+ * `tcp()` cannot run in a browser, and the prototype hard-coded it inside its
+ * node factory — so importing the transport module at all dragged a Node-only
+ * transport into a browser bundle, in a package whose whole claim is that one
+ * implementation runs on both. Separating the profiles is the fix, and the
+ * root's boundary test asserts `@libp2p/tcp` never appears there.
+ */
+import type { BytesStore } from "./identity.js";
+import type { TransportFactory } from "./transport.js";
+/**
+ * Transports for a server: TCP, and nothing a page could not also do.
+ *
+ * Listed as a function rather than a constant so a caller gets fresh factory
+ * instances — libp2p's are not reusable across nodes.
+ */
+export declare function nodeTransports(): TransportFactory[];
+/**
+ * A `BytesStore` on the filesystem — where a server keeps its identity.
+ *
+ * WRITE-THEN-MOVE, not write-in-place. A key file truncated by a crash
+ * mid-write is not a corrupt file you notice, it is a mesh that silently
+ * re-founds itself on the next start: `identityStore.loadOrCreate` sees
+ * unreadable bytes, generates a new key, and every token the old identity
+ * issued stops verifying. A rename is atomic on POSIX, so the file is either
+ * the old key or the new one and never half of either.
+ *
+ * The prototype's snapshot store wrote in place; extraction prototype 04
+ * measured the consequence and this is the shape that survived it.
+ */
+export declare function fileBytesStore(dir: string): BytesStore;
+//# sourceMappingURL=node.d.ts.map

package/dist/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../src/node.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAKH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAChD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAEvD;;;;;GAKG;AACH,wBAAgB,cAAc,IAAI,gBAAgB,EAAE,CAEnD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAuBtD"}

package/dist/node.js

@@ -0,0 +1,60 @@
+/**
+ * The Node profile. Everything here is why the root export is not this.
+ *
+ * `tcp()` cannot run in a browser, and the prototype hard-coded it inside its
+ * node factory — so importing the transport module at all dragged a Node-only
+ * transport into a browser bundle, in a package whose whole claim is that one
+ * implementation runs on both. Separating the profiles is the fix, and the
+ * root's boundary test asserts `@libp2p/tcp` never appears there.
+ */
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { tcp } from "@libp2p/tcp";
+/**
+ * Transports for a server: TCP, and nothing a page could not also do.
+ *
+ * Listed as a function rather than a constant so a caller gets fresh factory
+ * instances — libp2p's are not reusable across nodes.
+ */
+export function nodeTransports() {
+    return [tcp()];
+}
+/**
+ * A `BytesStore` on the filesystem — where a server keeps its identity.
+ *
+ * WRITE-THEN-MOVE, not write-in-place. A key file truncated by a crash
+ * mid-write is not a corrupt file you notice, it is a mesh that silently
+ * re-founds itself on the next start: `identityStore.loadOrCreate` sees
+ * unreadable bytes, generates a new key, and every token the old identity
+ * issued stops verifying. A rename is atomic on POSIX, so the file is either
+ * the old key or the new one and never half of either.
+ *
+ * The prototype's snapshot store wrote in place; extraction prototype 04
+ * measured the consequence and this is the shape that survived it.
+ */
+export function fileBytesStore(dir) {
+    return {
+        async get(key) {
+            try {
+                return new Uint8Array(await readFile(join(dir, key)));
+            }
+            catch (error) {
+                if (error.code === "ENOENT")
+                    return undefined;
+                throw error;
+            }
+        },
+        async set(key, value) {
+            await mkdir(dir, { recursive: true });
+            const target = join(dir, key);
+            // Same directory, so the rename cannot cross a filesystem boundary —
+            // which is the one case where it would stop being atomic.
+            const staging = `${target}.${process.pid}.${Date.now()}.tmp`;
+            await writeFile(staging, value, { mode: 0o600 });
+            await rename(staging, target);
+        },
+        async delete(key) {
+            await rm(join(dir, key), { force: true });
+        },
+    };
+}

package/dist/reservation.d.ts

@@ -0,0 +1,245 @@
+/**
+ * Dialing the relay, and waiting for the reservation it grants afterwards.
+ *
+ * TRANSPORT-NEUTRAL ON PURPOSE, AND THAT IS WHY IT LIVES HERE. Both halves
+ * of this module touch nothing but `Libp2p.dial` and `Libp2p.getMultiaddrs`,
+ * so they are identical for a browser node (`browser/node-profile.ts`), a
+ * Node hub (`hub/node-profile.ts`) and a test peer (`tests/e2e/harness.ts`).
+ * They used to live in `browser/node-profile.ts`, whose top-level imports
+ * include `@libp2p/webrtc` -- which is why `tests/e2e/harness.ts` grew a
+ * second, hand-copied poll loop rather than import them (Task 14 reported
+ * that duplication as a finding). `@libp2p/webrtc` now loads under Node
+ * (its `node-datachannel` binary is installed, Task 20 Step 1), so the
+ * import would work today; the copy is still gone because ONE poll loop
+ * with one timing contract is the point, not because importing was
+ * impossible.
+ *
+ * READINESS IS POLLED, NOT AWAITED (design note 17 §4). `node.dial(relay)`
+ * resolving means the connection to the relay opened -- it says nothing
+ * about whether the relay has finished granting a reservation. That
+ * reservation lands asynchronously afterwards, so `waitForCircuitReservation`
+ * polls `getMultiaddrs()` until a `p2p-circuit` address actually appears, on
+ * the same schedule (250 ms x 40 attempts = 10 s ceiling) the validated
+ * relay test used (`prototypes/16-.../src/relay.test.ts`). Treating `dial`'s
+ * resolution as "ready" is exactly the race that note documents this project
+ * already got bitten by once.
+ */
+import type { Libp2p } from "@libp2p/interface";
+import { type RelayReservationGrant } from "./hop-reserve.js";
+import { type Timers } from "./timers.js";
+/** Dial the relay named by `relayAddr` (`httpeers.json`'s `relayAddrs[0]`). Resolving means the link is up -- NOT that a circuit reservation exists yet; see `waitForCircuitReservation`. */
+export declare function dialRelay(node: Libp2p, relayAddr: string): Promise<void>;
+/** How often `waitForCircuitReservation` re-checks `getMultiaddrs()`. */
+export declare const RESERVATION_POLL_INTERVAL_MS = 250;
+/** How many times it checks before giving up -- 40 x 250 ms = 10 s, the ceiling the validated relay test (`relay.test.ts`) used. */
+export declare const RESERVATION_POLL_ATTEMPTS = 40;
+export interface WaitForCircuitReservationInit {
+    intervalMs?: number;
+    attempts?: number;
+}
+/**
+ * Poll `node.getMultiaddrs()` until a `p2p-circuit` address appears,
+ * returning it as a string. See this module's own "READINESS IS POLLED,
+ * NOT AWAITED" note for why this exists instead of trusting `dialRelay`'s
+ * resolution: the reservation is granted by the relay asynchronously,
+ * after the dial itself has already resolved.
+ */
+export declare function waitForCircuitReservation(node: Libp2p, init?: WaitForCircuitReservationInit): Promise<string>;
+/**
+ * WHAT `superviseRelay` NOW DOES, AND WHY IT IS NOT WHAT IT USED TO DO.
+ *
+ * The supervisor below used to answer "am I reserved?" from
+ * `node.getMultiaddrs()` -- the node's OWN belief, held by libp2p's transport
+ * reservation store. On 2026-09-19 that belief was wrong for hours: the relay
+ * held no reservation for the hub, the websocket to it was still ESTABLISHED,
+ * every member got `NO_RESERVATION`, and the supervisor saw a perfectly good
+ * `/p2p-circuit` address and did nothing. Only a container restart fixed it,
+ * and the root cause on the relay's side was never found -- which is the
+ * argument for repairing the CLASS of fault rather than that one cause.
+ *
+ * So the relay decides now. On a schedule well inside the reservation's TTL
+ * the supervisor asks the relay for a reservation over the connection it
+ * already holds (`./hop-reserve.ts`, which explains the wire-level choice).
+ * That single request is both the question and the repair: a relay's
+ * reservation store is keyed by peer, so the answer is OK whether it renewed
+ * an entry or created a missing one. The incident therefore heals on the next
+ * tick without anything having to notice it first -- and if the relay instead
+ * REFUSES, or cannot be asked at all, that is a loss, with the backoff and
+ * `restore` path below.
+ *
+ * THE LOCAL ADDRESS LIST STILL EARNS ITS KEEP, in one direction only: an
+ * address that has GONE is proof of a loss (libp2p removes it when the relay
+ * connection closes), and reacting to it turns a dropped link into a restore
+ * in milliseconds rather than at the next renewal. An address that is PRESENT
+ * proves nothing and can no longer put the supervisor back into `reserved` --
+ * `tests/reservation-supervisor.test.ts` pins exactly that asymmetry.
+ *
+ * NOTHING IS SWALLOWED. Every transition logs one line naming the relay and
+ * the reason. The old implementation had a bare `catch {}` around the whole
+ * restore, which is why the incident left no trace in the hub's own output.
+ */
+/** Where a supervised reservation stands. `stopped` is terminal. */
+export type RelayReservationStatus = "reserved" | "lost" | "stopped";
+/** Every transition the supervisor logs. There is no "gave up": it retries forever, with a capped backoff, and the health signal is what escalates. */
+export type RelayReservationEvent = "reserved" | "renewed" | "renewal-failed" | "lost" | "restoring" | "restored" | "restore-failed" | "stopped";
+/** A supervisor's current view, as `GET /hub/api/relay` reports it. */
+export interface RelayReservationState {
+    status: RelayReservationStatus;
+    relayAddr: string;
+    /** The relay's peer id, or `null` when `relayAddr` names none. */
+    relayPeerId: string | null;
+    /** When the RELAY last confirmed the reservation (ms since the epoch); `null` until it first has. */
+    verifiedAt: number | null;
+    /** When the relay says the reservation expires (ms since the epoch); `null` when it did not say. */
+    expiresAt: number | null;
+    /** When the loss was first noticed (ms since the epoch); `null` while reserved. */
+    lostSince: number | null;
+    /** Renewals or restores that have failed in a row. Zero the moment the relay says OK. */
+    consecutiveFailures: number;
+    /** Relay-confirmed renewals since this supervisor started. */
+    renewals: number;
+    /** Recoveries completed since this supervisor started. */
+    restores: number;
+    /** The most recent failure, verbatim; kept after recovery so an operator can see what happened. */
+    lastError: string | null;
+}
+/** One line, plus the structured form of the same thing. */
+export type RelayLog = (message: string, detail: {
+    event: RelayReservationEvent;
+    state: RelayReservationState;
+}) => void;
+export interface SuperviseRelayInit {
+    node: Libp2p;
+    /**
+     * The same string `dialRelay` was given. Its last `/p2p/<id>` names the
+     * relay whose reservation counts; with a custom `restore`, `/p2p/<id>`
+     * alone is enough. Without any `/p2p/<id>` there is nobody to ask, and
+     * proactive renewal is off.
+     */
+    relayAddr: string;
+    /**
+     * How to get the reservation back. Defaults to dialling `relayAddr` and
+     * waiting for libp2p to reserve on it, which is right for a relay libp2p
+     * DISCOVERED (a `/p2p-circuit` listen address). A CONFIGURED relay -- a
+     * member's reservation on its hub -- is never re-reserved by libp2p, so its
+     * restore has to ask again itself; see `./hub-link.ts`.
+     */
+    restore?: () => Promise<void>;
+    /** The first retry after a failed attempt. */
+    minRetryDelayMs?: number;
+    /** The ceiling the backoff grows to. */
+    maxRetryDelayMs?: number;
+    /**
+     * Ask the relay itself. Defaults to a circuit-relay v2 HOP `RESERVE` over
+     * the connection this node already holds (`requestRelayReservation`).
+     * `false` turns proactive renewal off entirely, which leaves only the
+     * address-disappeared detector -- i.e. the behaviour that missed the
+     * incident. It exists for tests, not for production.
+     */
+    verify?: ((options: {
+        signal?: AbortSignal;
+    }) => Promise<RelayReservationGrant>) | false;
+    /**
+     * How long between renewals. Defaults to a quarter of the TTL the relay
+     * itself reported in its last grant -- see `renewalIntervalMs`.
+     */
+    renewalIntervalMs?: number;
+    /** The backstop check for a loss no event reported. */
+    checkIntervalMs?: number;
+    /** Defaults to the global timers; a browser tab should pass `worker-timers` (see `./timers.ts`). */
+    timers?: Timers;
+    /** Defaults to one `console.log` per transition. A silent supervisor is what hid the incident. */
+    log?: RelayLog;
+    now?: () => number;
+    random?: () => number;
+}
+export interface RelaySupervisor {
+    /** Re-check now, and if the reservation is gone try at once rather than wait out the backoff. */
+    poke(): void;
+    /** What the relay last said, and when. Safe to call at any time; a copy, not the live object. */
+    state(): RelayReservationState;
+    stop(): void;
+}
+/**
+ * The floor and ceiling on the renewal cadence, and the cadence used when the
+ * relay has not told us a TTL yet.
+ *
+ * A QUARTER OF THE TTL is the rule (`renewalIntervalMs`). Against the relay
+ * this project runs -- `apps/relay/src/limits.ts`, TTL two hours, restated
+ * there precisely so a library change is visible -- that is thirty minutes,
+ * and it means three consecutive renewals can fail before the reservation
+ * would lapse on its own. A half would leave room for one, which is no margin
+ * at all; an eighth would double the traffic for a margin nobody needs.
+ *
+ * The CEILING is the same thirty minutes, so a relay that one day advertises a
+ * longer TTL does not stretch the cadence with it: the incident was not a
+ * reservation that expired, it was one that vanished, and how fast that is
+ * repaired is bounded by this number, not by the TTL. The FLOOR keeps a relay
+ * with an implausibly short TTL from being asked every few seconds.
+ */
+export declare const MIN_RENEWAL_INTERVAL_MS = 60000;
+export declare const MAX_RENEWAL_INTERVAL_MS: number;
+export declare const DEFAULT_RENEWAL_INTERVAL_MS: number;
+/** The renewal cadence for a reservation the relay says lasts `ttlMs`. See the constants above. */
+export declare function renewalIntervalMs(ttlMs: number | null | undefined): number;
+/**
+ * The actual wait before the next renewal: `intervalMs` jittered DOWN into its
+ * upper quarter, never up.
+ *
+ * Down, because the interval is already the deadline -- stretching it past a
+ * quarter of the TTL would spend the margin the quarter exists to buy. The
+ * spread is what keeps a fleet of hubs that started together, or came back
+ * together after a relay restart, from asking the relay in the same instant
+ * for ever after.
+ */
+export declare function renewalDelayMs(intervalMs: number, random?: () => number): number;
+/**
+ * How long a lost reservation may go unrepaired before the hub should call
+ * itself unhealthy.
+ *
+ * TWO MINUTES. A restore normally completes in seconds: the loss is noticed
+ * either at once (the address disappears) or at the next renewal, the restore
+ * dials and waits at most five seconds for the reservation, and the retry
+ * backoff caps at thirty. Two minutes is therefore at least four attempts
+ * including capped retries -- long enough that a relay restart or a dropped
+ * link never shows up as an unhealthy appliance, short enough to be a small
+ * fraction of the two-hour TTL, so a hub that truly cannot get back is
+ * reported long before members would notice on their own.
+ */
+export declare const RESERVATION_LOSS_GRACE_MS = 120000;
+/** Is this state healthy -- reserved, or lost for less than `graceMs`? See `RESERVATION_LOSS_GRACE_MS`. */
+export declare function reservationHealthy(state: Pick<RelayReservationState, "status" | "lostSince">, graceMs?: number, now?: number): boolean;
+/**
+ * Keep this node's reservation on the relay at `relayAddr`: renew it against
+ * the relay on a schedule, and re-dial whenever it is lost. Call once the
+ * first reservation has landed.
+ */
+export declare function superviseRelay(init: SuperviseRelayInit): RelaySupervisor;
+/**
+ * The wait before retry number `failures` (0-based): doubling from
+ * `minDelayMs`, capped at `maxDelayMs`, then jittered into its upper half
+ * so a relay restart does not bring every peer back in the same instant.
+ */
+export declare function retryDelayMs(failures: number, minDelayMs: number, maxDelayMs: number, random?: () => number): number;
+/** The circuit addresses a node currently holds, split by kind. */
+export interface CircuitAddrs {
+    /** `/…/p2p-circuit/p2p/<self>` — reachable through the relay, no WebRTC. */
+    bare?: string;
+    /** `/…/p2p-circuit/webrtc/p2p/<self>` — the relay carries only the handshake. */
+    webrtc?: string;
+}
+/**
+ * Which of a node's addresses a peer should actually be told.
+ *
+ * After reserving, a node carries several multiaddrs at once and they are NOT
+ * interchangeable: its own transport address is not reachable through a relay
+ * at all, the bare circuit relays every byte, and the `/webrtc` circuit uses
+ * the relay for the handshake only and then talks directly. Handing out the
+ * wrong one is a connection that fails for a reason nobody can read from the
+ * error.
+ *
+ * Each assembly in the prototype picked one inline, and differently — the kind
+ * of triplication the extraction exists to end.
+ */
+export declare function circuitAddrs(node: Libp2p): CircuitAddrs;
+//# sourceMappingURL=reservation.d.ts.map

package/dist/reservation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reservation.d.ts","sourceRoot":"","sources":["../src/reservation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,EAAE,KAAK,qBAAqB,EAA2B,MAAM,kBAAkB,CAAC;AAEvF,OAAO,EAAkC,KAAK,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1E,6LAA6L;AAC7L,wBAAsB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE9E;AAED,yEAAyE;AACzE,eAAO,MAAM,4BAA4B,MAAM,CAAC;AAChD,oIAAoI;AACpI,eAAO,MAAM,yBAAyB,KAAK,CAAC;AAE5C,MAAM,WAAW,6BAA6B;IAC5C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;GAMG;AACH,wBAAsB,yBAAyB,CAC7C,IAAI,EAAE,MAAM,EACZ,IAAI,GAAE,6BAAkC,GACvC,OAAO,CAAC,MAAM,CAAC,CAcjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,oEAAoE;AACpE,MAAM,MAAM,sBAAsB,GAAG,UAAU,GAAG,MAAM,GAAG,SAAS,CAAC;AAErE,uJAAuJ;AACvJ,MAAM,MAAM,qBAAqB,GAC7B,UAAU,GACV,SAAS,GACT,gBAAgB,GAChB,MAAM,GACN,WAAW,GACX,UAAU,GACV,gBAAgB,GAChB,SAAS,CAAC;AAEd,uEAAuE;AACvE,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,sBAAsB,CAAC;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,kEAAkE;IAClE,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,qGAAqG;IACrG,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,oGAAoG;IACpG,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,mFAAmF;IACnF,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,yFAAyF;IACzF,mBAAmB,EAAE,MAAM,CAAC;IAC5B,8DAA8D;IAC9D,QAAQ,EAAE,MAAM,CAAC;IACjB,0DAA0D;IAC1D,QAAQ,EAAE,MAAM,CAAC;IACjB,mGAAmG;IACnG,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAED,4DAA4D;AAC5D,MAAM,MAAM,QAAQ,GAAG,CACrB,OAAO,EAAE,MAAM,EACf,MAAM,EAAE;IAAE,KAAK,EAAE,qBAAqB,CAAC;IAAC,KAAK,EAAE,qBAAqB,CAAA;CAAE,KACnE,IAAI,CAAC;AAEV,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb;;;;;OAKG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9B,8CAA8C;IAC9C,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,wCAAwC;IACxC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,CAAC,CAAC,OAAO,EAAE;QAAE,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,KAAK,OAAO,CAAC,qBAAqB,CAAC,CAAC,GAAG,KAAK,CAAC;IACzF;;;OAGG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,uDAAuD;IACvD,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,oGAAoG;IACpG,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,kGAAkG;IAClG,GAAG,CAAC,EAAE,QAAQ,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,eAAe;IAC9B,iGAAiG;IACjG,IAAI,IAAI,IAAI,CAAC;IACb,iGAAiG;IACjG,KAAK,IAAI,qBAAqB,CAAC;IAC/B,IAAI,IAAI,IAAI,CAAC;CACd;AAWD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,uBAAuB,QAAS,CAAC;AAC9C,eAAO,MAAM,uBAAuB,QAAc,CAAC;AACnD,eAAO,MAAM,2BAA2B,QAAc,CAAC;AAEvD,mGAAmG;AACnG,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAG1E;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,GAAE,MAAM,MAAoB,GAAG,MAAM,CAE7F;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,yBAAyB,SAAU,CAAC;AAEjD,2GAA2G;AAC3G,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,IAAI,CAAC,qBAAqB,EAAE,QAAQ,GAAG,WAAW,CAAC,EAC1D,OAAO,GAAE,MAAkC,EAC3C,GAAG,GAAE,MAAmB,GACvB,OAAO,CAIT;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,kBAAkB,GAAG,eAAe,CAuNxE;AAgBD;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,MAAM,GAAE,MAAM,MAAoB,GACjC,MAAM,CAGR;AAED,mEAAmE;AACnE,MAAM,WAAW,YAAY;IAC3B,4EAA4E;IAC5E,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,iFAAiF;IACjF,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,CAavD"}