@cello-protocol/daemon 0.0.225 → 0.0.227

package/dist/standing-receivers.d.ts

@@ -1,319 +0,0 @@
-/**
- * CELLO Daemon — THE STANDING RECEIVER: THE NODE THAT IS ALWAYS LISTENING
- *
- * Split out of `session-node-manager.ts` by 037-SESSIONCORE. One pre-created node per agent, kept
- * alive at all times and handed to the first inbound session — then immediately replaced, so there
- * is always one waiting.
- *
- * ⚠️ **ITS GATER IS NOT OPEN, and this sentence used to say it was.** `DOD-M15-ASSIGN-1` closed
- * exactly that: the gater admits NOBODY inbound until a session offer names the dialer, while
- * leaving this node's own outbound errands open (`allowedPeerId: null` — see the construction
- * below, which says the same thing in the imperative).
- *
- * The wrong version is called out rather than quietly corrected because of what believing it costs:
- * a reader who thinks the gater is open reads an unnamed-dialer rejection as a BUG and opens it, or
- * waves off the hardening as already done. It was inherited from the manager's own header, which is
- * corrected in the same commit.
- *
- * Moved verbatim, comments included.
- *
- * ⚠️ ITS ABSENCE IS THE FIRST SUSPECT WHEN A LIVE SESSION FAILS. `standing_receiver_unavailable`,
- * an empty counterparty peer id, `Invalid peer ID: ""` — all of them start here. The receiver is
- * created when the agent is STARTED, not at daemon boot, so an agent that was never started has no
- * receiver and nothing to hand an inbound session.
- */
-import type { Logger } from "./types.js";
-import { NodeAutoNatService, type CelloNode, type IAutoNatService } from "@cello-protocol/transport";
-import { SessionConnectionGater } from "./session-connection-gater.js";
-import type { DaemonDatabase } from "./sqlcipher-db.js";
-import type { ISessionNodeFactory } from "./session-node-types.js";
-import { type SessionNodeConfig } from "./session-node-types.js";
-import type { SessionRecords } from "./session-records.js";
-import type { ParkRecovery } from "./park-recovery.js";
-/** What the standing receiver needs from the manager. */
-export interface StandingReceiverContext {
-    readonly logger: Logger;
-    readonly records: SessionRecords;
-    readonly park: ParkRecovery;
-    /**
-     * 055-ONDEMAND — has the session this offer was for actually started? Read when the abandoned-offer
-     * timer fires, so a slot taken for an offer that went nowhere is given back.
-     */
-    sessionIsLive(agentName: string, sessionIdHex: string): boolean;
-    /** 055-ONDEMAND — does any of this agent's live sessions hold a circuit right now? */
-    anyLiveSessionHoldsCircuit(agentName: string): boolean;
-    readonly factory: ISessionNodeFactory;
-    /** A function: the manager opens its database after construction. Re-exposed below as `#db`. */
-    db(): DaemonDatabase | null;
-    shuttingDown(): boolean;
-    sessionKey(agentName: string, sessionId: string): string;
-    /**
-     * ⚠️ THESE MAPS ARE SHARED BY REFERENCE, NOT OWNED HERE. The reservation watchdog, the relay
-     * paths and session creation all read them and all stayed behind, so giving this module its own
-     * copies would create two answers to "which agents have a receiver". Each is assigned exactly
-     * once, at construction, so there is one object and no divergence.
-     */
-    readonly standingReceivers: Map<string, {
-        node: CelloNode;
-        gater: SessionConnectionGater;
-        autoNat: NodeAutoNatService;
-        seed: Uint8Array;
-        relayPeerIds: string[];
-    }>;
-    readonly standingReceiverCreating: Set<string>;
-    readonly agentsWantingReceiver: Set<string>;
-    readonly standingReceiverRemoving: Set<string>;
-    readonly srReservationRetry: Map<string, {
-        attempts: number;
-        nextAt: number;
-        correlationId: string;
-        lastReason?: string;
-    }>;
-    readonly srLastRejectionReason: Map<string, string>;
-    readonly directoryRelayEndpoints: Map<string, Array<{
-        relayPeerId: string;
-        relayAddrs: string[];
-    }>>;
-    readonly srRetryDelaysMs: number[];
-    readonly srReservationTimeoutMs: number;
-    /** The AutoNAT prober list, injected by the composition root. */
-    autoNatProbers(): string[];
-    /**
-     * 055-ONDEMAND — tell a relay this agent is done with its slot. Best-effort: a release that
-     * could not be delivered costs a slot until its TTL and must never fail a seal.
-     */
-    tellRelayReleased(agentName: string, relayPeerId: string, node: CelloNode, correlationId: string): Promise<void>;
-    proveToRelay(agentName: string, circuitAddr: string, node: CelloNode, correlationId: string, surfaceAsReceiverRefusal: boolean): Promise<"proven" | "refused_try_another_relay" | "refused_this_agent" | "unavailable">;
-    reservationCircuitAddrs(agentName: string): {
-        addrs: string[];
-        relayPeerIds: string[];
-    };
-    authenticateStandingReceiver(agentName: string, node: CelloNode, relayPeerId: string, heldCircuitAddr: string, correlationId: string): Promise<void>;
-}
-export declare class StandingReceivers {
-    #private;
-    constructor(ctx: StandingReceiverContext);
-    /**
-     * 055-ONDEMAND — re-take a circuit on a node that already exists, for a live session that lost it.
-     *
-     * ⚠️ **IT PROVES OVER THE DELIVERY PATH TOO.** `DOD-M15-RELAYAUTH-1` applies identically here: a
-     * holder that has not proven key possession has its reservation revoked inside the relay's grace
-     * window, about fifteen seconds. The first version of the re-take called the low-level ask
-     * directly and skipped it, so a re-taken circuit would have been revoked almost immediately while
-     * the log said "granted" — the same defect this unit already fixed one function up.
-     */
-    retakeReservationOn(agentName: string, node: CelloNode, circuitAddr: string, correlationId: string): Promise<boolean>;
-    takeReservationForSession(agentName: string, circuitAddr: string, correlationId: string, 
-    /**
-     * ⚠️ **PRESENT ONLY ON THE OFFER PATH, AND THAT IS WHAT ARMS THE ABANDONED-OFFER RELEASE.**
-     *
-     * The first version reused `correlationId` for this, because the offer handler happens to pass
-     * the session id as its correlation id. Two meanings in one parameter is how a value ends up
-     * being trusted for something it was never chosen for: the watchdog's re-take passes a genuine
-     * correlation id, and it would have armed a timer keyed on a string that is not a session.
-     *
-     * Absent for the re-take path, which is by definition for a session that is already live.
-     */
-    offerSessionIdHex?: string): Promise<boolean>;
-    /**
-     * 055-ONDEMAND — **GIVE THIS SESSION'S SLOT BACK, FROM THE NODE THAT ACTUALLY HOLDS IT.**
-     *
-     * ⚠️ **THE FIRST VERSION LOOKED THE NODE UP BY AGENT NAME AND ALWAYS FOUND THE WRONG ONE.** When a
-     * session opens, the standing receiver is PROMOTED: `session-lifecycle` deletes it from
-     * `standingReceivers`, moves that exact node into `activeNodes`, and builds a fresh empty receiver
-     * behind it. So by seal time `standingReceivers.get(agentName)` is the new idle node, holding
-     * nothing — the release read `[]`, returned immediately, and told the relay nothing. The slot the
-     * offer took lived on the promoted node and died with it, invisible to the relay, held for the
-     * full TTL. **A release that always no-ops is worse than none: it logs success.**
-     *
-     * ⚠️ **AND THE CROSS-SESSION RECOMPUTE THE ORDER ASKED FOR IS UNNECESSARY, which is the good news
-     * in the correction.** libp2p's shared `reservationStore` is shared *within one node*. Each live
-     * session owns its OWN node, so sealing one cannot clear another session's refresh timers. There
-     * is nothing to recompute: this node is being torn down anyway, so tell its relays and drop its
-     * circuits. Re-deriving that removed a whole class of drift rather than managing it.
-     */
-    releaseSessionReservation(agentName: string, node: CelloNode, sessionId: string, correlationId: string): Promise<void>;
-    /**
-     * DOD-LOOP-1: ensure the given agent has a standing receiver node (idempotent). Created when an
-     * agent comes online (cello_start_agent) and replaced after it is handed off to a session. The
-     * `#standingReceiverCreating` guard prevents two concurrent ensure() calls (e.g. the
-     * cello_start_agent hook racing a consume-site retry) from building two nodes for one agent.
-     *
-     * M8B F14: a create failure no longer strands the agent deaf. Each ensure runs a BOUNDED
-     * retry loop (`standingReceiverRetryDelaysMs`, default 1s/5s/15s) — covering the fixed-port
-     * race where the consumed receiver still holds the port until its session node is torn down —
-     * and when every attempt fails, fires the alarm-worthy `session.standing_receiver.dead`
-     * (error level), distinct from the per-attempt `session.node.create.failed`. Re-arm is also
-     * kicked from destroySessionNode/retireSessionNode (the moment the port frees) and from the
-     * inbound accept path (ensure on demand), so one failure can never leave the agent deaf forever.
-     */
-    ensureStandingReceiver(agentName: string, correlationId?: string): Promise<void>;
-    /**
-     * DOD-M12B-SESSION-SEED-1 — build a revived session node that is REACHABLE, without ever hanging.
-     *
-     * MEASURED 2026-08-18, live, three ways:
-     *   - handed 2 relay addrs at once, no deadline:  `start()` never completes (10,002ms and counting)
-     *   - handed none:                                `start()` in 1ms, but NOBODY can dial the node —
-     *                                                 the counterparty's re-dial fails
-     *                                                 `counterparty_dial_failed` and every message in
-     *                                                 both directions has to go the relay park route
-     *   - this:                                       one candidate at a time, each raced against its
-     *                                                 own deadline, plain node as the floor
-     *
-     * The middle option is what shipped for one test run and it made the session half-dead: revived,
-     * `active`, and unreachable. The first is what shipped before that and it hung. Neither is a
-     * choice between "fast" and "reliable" — the per-candidate race is how `#startReceiverNode` has
-     * always done it, and it is the shape that works in production every day.
-     *
-     * A FAILED CANDIDATE IS TORN DOWN AT SETTLEMENT. The first version awaited `stop()` immediately
-     * and claimed that made seed reuse safe; it did not — `libp2p.stop()` returns at once unless the
-     * node is `'started'`, and during the timeout window it is `'starting'` (review HIGH-3, verified
-     * against libp2p 3.3.2). The teardown is now chained onto the candidate's OWN start promise, so it
-     * runs whenever that settles, however late.
-     *
-     * A BRIEF OVERLAP IS THEREFORE POSSIBLE and is stated rather than denied: a candidate that grants
-     * at 4s comes up on this session's peer id and is stopped immediately after. What is guaranteed is
-     * that it dies, not that it never lives. The receiver path avoids even that by minting a seed per
-     * candidate; here the identity is fixed, which is the whole point of a revival, so that option
-     * does not exist.
-     *
-     * The floor is a plain node: a session that is usable over the relay park route beats no session.
-     */
-    buildRevivedNode(sessionId: string, gater: SessionConnectionGater, seed: Uint8Array, candidateAddrs: string[], agentName: string): Promise<CelloNode>;
-    /**
-     * DOD-M15-RELAYONLY-1: build a transport node for THIS AGENT, with its privacy posture applied.
-     *
-     * ⚠️ THE CHOKE POINT FOR NODE CREATION, and it exists for the same reason as the one around
-     * `getStandingReceiverInfo`. Five call sites construct nodes; passing `relayOnly` at each would be
-     * a hand-kept list, and the SIXTH — added next month by someone who has never read this line —
-     * would build a node that hole-punches its way to a direct connection for an operator who asked
-     * never to be directly reachable. Here, a new caller inherits the posture instead of being told.
-     *
-     * `unknown` counts as ON, matching the publish and dial halves: a node that declines to hole-punch
-     * is reachable over the relay, while a disclosed address cannot be recalled.
-     */
-    createAgentNode(agentName: string, config: SessionNodeConfig): Promise<CelloNode>;
-    /**
-     * DOD-PARK-DRAIN-1 (review F6): why there is no standing-receiver node to dial from — named
-     * precisely, because `standing_receiver_unavailable` is the exit-point label that stood in for
-     * four different causes and misnamed this very incident 102 times.
-     *
-     * Only meaningful once `getStandingReceiverNode()` has returned null, which means NO agent on
-     * this daemon has a ready receiver — the dial node is not agent-scoped.
-     */
-    standingReceiverAbsenceReason(agentName: string): "daemon_shutting_down" | "standing_receiver_creating" | "agent_offline" | "no_standing_receiver";
-    getStandingReceiverInfo(agentName: string): {
-        peerId: string;
-        addrs: string[];
-    } | null;
-    /** DOD-LOOP-1: whether the given agent has a standing receiver ready (any agent if omitted). */
-    getStandingReceiverReady(agentName?: string): boolean;
-    /**
-     * The standing receiver's libp2p node — a general-purpose node usable for OUTBOUND dials that
-     * are not session-scoped (e.g. the content-park deposit/pull to the relay, MSG-001-3b). Its
-     * gater admits nobody INBOUND until a session names them (DOD-M15-ASSIGN-1), but leaves these
-     * outbound errands open. Returns null until the receiver is ready.
-     */
-    getStandingReceiverNode(agentName?: string): CelloNode | null;
-    /**
-     * DOD-M12B-RESERVATION-RETRY-1 — whether a NAT'd peer can actually DIAL this agent.
-     *
-     * `standing_receiver_ready` answers "is there a receiver?", which is true for a plain TCP node
-     * that no relay would give a circuit reservation to. Behind NAT that node is reachable by nobody,
-     * and the difference was visible only in the log — where it was visible 481 times and nobody
-     * acted. `"retrying"` and `"unreachable"` are the states an operator can do something about.
-     *
-     *   reserved    — holds a circuit reservation; a NAT'd peer can dial it.
-     *   retrying    — no reservation yet, still re-asking on a backoff.
-     *   unreachable — no circuit reservation and the automatic re-attempts are spent, so only peers
-     *                 that can connect DIRECTLY will get in. It is not permanent: a directory
-     *                 reconnect carrying a DIFFERENT relay pool re-arms the budget, because a relay we
-     *                 have never tried is new information.
-     *   absent      — no receiver at all (the agent is not online).
-     */
-    getStandingReceiverReachability(agentName: string): "reserved" | "ready" | "retrying" | "unreachable" | "absent";
-    /**
-     * CELLO-M7-TRANSPORT-001: the AutoNAT service wrapping the current standing
-     * receiver node, or null if the standing receiver is not ready. The composition
-     * root uses this as the daemon's runtime IAutoNatService — its getDialability()
-     * drives the SessionAssignment advertised address (AC-004/AC-019), and it is the
-     * source of the transport.autonat.result / transport.autonat.unavailable events.
-     */
-    getStandingReceiverAutoNat(): IAutoNatService | null;
-    /**
-     * Which peer this agent's standing receiver is currently admitting INBOUND — `null` for nobody.
-     *
-     * Read-only, and it answers a question the daemon otherwise cannot: *"whose dial would this
-     * receiver accept right now?"* The gate is narrowed and re-closed from several paths (an offer
-     * arrives, an assignment is refused, a session is promoted), and until now the only way to know
-     * where it had ended up was to reproduce the sequence in your head.
-     *
-     * Added for `DOD-M15-RESPONDER-VERIFY-1`, where a refusal for one session was closing the gate a
-     * DIFFERENT session had narrowed — a defect with no observable symptom short of the second
-     * session's initiator being refused with "nothing invited it".
-     */
-    getStandingReceiverAllowedPeer(agentName: string): string | null;
-    /**
-     * DOD-M15-ASSIGN-1 — name the one peer allowed to dial this agent's standing receiver, at the
-     * moment the directory's `session_offer` says who is coming.
-     *
-     * This is what makes the receiver's deny-by-default safe. The offer names
-     * `initiator_session_peer_id`, and the responder answers it by advertising its OWN address in
-     * `session_offer_accept`. Narrowing here — BEFORE that answer goes out — means the door opens to
-     * exactly one peer at the same instant the address that reaches them is published, and never
-     * before. The initiator cannot know where to dial until the accept it triggers has been sent.
-     *
-     * Returns WHICH failure it was, never a bare false (review F6). The caller reports a distinct
-     * reason per cause: "no receiver" and "the directory named nobody" are different subsystems, and
-     * collapsing them sent the operator to the directory for a local problem. This method never
-     * widens the gate to compensate.
-     *
-     * Narrows INBOUND ONLY. The receiver is still the daemon's general-purpose dialer at this point
-     * — no assignment exists yet — so revoking its outbound latitude here would break content
-     * parking and restart-seal submission (review F2).
-     */
-    admitOfferedDialer(agentName: string, initiatorSessionPeerId: string, sessionIdHex: string): "narrowed" | "no_receiver" | "no_peer_named";
-    /**
-     * What the UNSIGNED offer claimed, so the SIGNED assignment can be checked against it.
-     *
-     * DOD-M15-OFFER-SIGNED-1. Decision 2 rules that the listening socket is "gated on the
-     * assignment", and the gate is narrowed from `session_offer` — a frame carrying no signature —
-     * because that is the only thing that arrives early enough. Timing forced the offer; it does not
-     * excuse trusting it.
-     *
-     * Keeping what the offer said turns the two frames into a CHECK ON EACH OTHER. The assignment is
-     * FROST-signed by the initiator's own threshold group, which no single directory can produce, and
-     * it names the same peer id. A directory that says one peer in the offer and another in the
-     * assignment is naming two different dialers for one session — which a truthful directory never
-     * does, and which is exactly the move a compromised one would make to slip a peer past the gate
-     * before the signed document arrives.
-     */
-    getOfferedDialer(agentName: string, sessionIdHex: string): string | null;
-    /** Forget the offered dialer for ONE session — called on BOTH the claim and the refusal paths. */
-    clearOfferedDialer(agentName: string, sessionIdHex: string): void;
-    /**
-     * RE-CLOSE the standing receiver — but ONLY if this session is still the one holding it.
-     *
-     * DOD-M15-OFFER-SIGNED-1 review F4, then N1. The first version closed the gate unconditionally,
-     * and that was worse than the defect it fixed: an agent has ONE standing receiver with ONE allowed
-     * peer, so a refusal for session P closed the gate that offer Q had narrowed. Q's initiator —
-     * invited, legitimate — was then refused with *"nothing invited it"*, which this daemon had.
-     *
-     * That is the same cross-session interference F1 was written to remove, moved one method along,
-     * and triggerable the same way: one bogus offer/assignment pair collapses a concurrent real
-     * session.
-     *
-     * So the gate is closed only when it still names the peer THIS session opened it to. If a later
-     * offer has already re-narrowed it, that offer owns the receiver and its narrowing stands.
-     *
-     * NO EVICTION SWEEP, deliberately (N4). The sweep evicts by "not the allowed peer", and
-     * `getConnections()` returns OUTBOUND connections too — including the content-park and
-     * restart-seal dials this node makes as the daemon's general-purpose dialer, whose targets are on
-     * no allowlist by construction. Sweeping here hung those up, and the failure surfaced as
-     * `relay_unavailable`: a transport label for a local decision, which is the exact substitution
-     * that comment was written to prevent. The load-bearing control is `DOD-M15-FRAME-1`'s frame gate,
-     * which refuses what an unauthorised peer sends; closing the door is enough here.
-     */
-    revokeOfferedDialer(agentName: string, sessionIdHex: string, offeredPeerId: string | null): void;
-}
-//# sourceMappingURL=standing-receivers.d.ts.map

package/dist/standing-receivers.d.ts.map

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