@macula-io/ts 0.13.5 → 0.14.0

package/README.md

@@ -235,6 +235,16 @@ fixed) is in [CHANGELOG.md](CHANGELOG.md).
   is why `keepAdvertisedDirect()` is a standalone function rather than a
   `Session` method.
 
+- **Pool** — `Pool.connect(seeds, controlIdentity, opts)` holds live
+  connections to every configured seed concurrently (not
+  dial-one-then-fallback-on-failure), each independently monitored and
+  respawned with backoff on disconnect; `publish()`/`call()` fan out
+  over live links, `subscribe()` re-establishes automatically on
+  reconnect. Ports `macula/src/client/macula_client.erl`'s pool design;
+  see `pool.ts`'s own module doc for why it's a set of role-scoped
+  `Session`s per seed rather than one, given the single-reader
+  constraint below.
+
 Every item above is live-verified against the real production fleet
 (`station-de-frankfurt.macula.io`), including negative/error paths and,
 where applicable, the actual packaged npm tarball rather than only the
@@ -257,21 +267,23 @@ arbitrary payload" function (see above for why), a `station_endpoint`
 record builder (macula-go has none either — stations publish those
 themselves, not clients), and `Pinned`/`Insecure` trust modes (`WebPKI`
 only so far). Multiple concurrent `subscribe()` topics on one `Session`
-also isn't supported yet — one `subscribe()` (like one `serve()`) per
-`Session` at a time; open a second `Session` for a second topic. Each of
-these is a separate, later slice of work built on top of a working
-`Session`.
+still isn't supported at the `Session` level itself — one `subscribe()`
+(like one `serve()`) per `Session` at a time; open a second `Session`
+for a second topic (`Pool`, above, does exactly this internally to give
+each tracked topic its own session). Each of these is a separate, later
+slice of work built on top of a working `Session`.
 
 ## Testing
 
 ```bash
 npx vitest run    # default suite, no network
-npm run test:live # MACULA_TS_LIVE=1 vitest run src/session.live.test.ts src/rpc.live.test.ts src/dht.live.test.ts src/pubsub.live.test.ts src/content.live.test.ts src/ucan.live.test.ts src/directdial.live.test.ts
+npm run test:live # MACULA_TS_LIVE=1 vitest run src/session.live.test.ts src/rpc.live.test.ts src/dht.live.test.ts src/pubsub.live.test.ts src/content.live.test.ts src/ucan.live.test.ts src/directdial.live.test.ts src/pool.live.test.ts
 ```
 
 `src/session.live.test.ts`, `src/rpc.live.test.ts`, `src/dht.live.test.ts`,
 `src/pubsub.live.test.ts`, `src/content.live.test.ts`,
-`src/ucan.live.test.ts`, and `src/directdial.live.test.ts` hit the real
+`src/ucan.live.test.ts`, `src/directdial.live.test.ts`, and
+`src/pool.live.test.ts` hit the real
 production fleet and are **not** part of default `npm test`/CI — opt in
 explicitly, gated behind `MACULA_TS_LIVE`. Same convention as macula-go's
 `live` build tag, macula-rust's `#[ignore]`, and macula-dotnet's

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export { Identity } from "./identity.js";
 export { Session, type CallOptions } from "./session.js";
+export { Pool, NoHealthyStationError, type Seed, type PoolOptions, type PoolStatus } from "./pool.js";
 export { MaculaCallError, type JsonValue, type Bolt4ErrorInfo } from "./rpc.js";
 export { DhtRecordType, DHT_DEFAULT_TTL_MS, type DhtRecord } from "./dht.js";
 export type { PublishOptions, PubsubEvent } from "./pubsub.js";

package/dist/index.js

@@ -1,5 +1,6 @@
 export { Identity } from "./identity.js";
 export { Session } from "./session.js";
+export { Pool, NoHealthyStationError } from "./pool.js";
 export { MaculaCallError } from "./rpc.js";
 export { DhtRecordType, DHT_DEFAULT_TTL_MS } from "./dht.js";
 export { ContentNotFoundError } from "./content.js";

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,OAAO,EAAoB,MAAM,cAAc,CAAC;AACzD,OAAO,EAAE,eAAe,EAAuC,MAAM,UAAU,CAAC;AAChF,OAAO,EAAE,aAAa,EAAE,kBAAkB,EAAkB,MAAM,UAAU,CAAC;AAE7E,OAAO,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,EAAE,IAAI,EAAiE,MAAM,WAAW,CAAC;AAChG,OAAO,EACL,oBAAoB,EACpB,kCAAkC,GAInC,MAAM,iBAAiB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,OAAO,EAAoB,MAAM,cAAc,CAAC;AACzD,OAAO,EAAE,IAAI,EAAE,qBAAqB,EAAgD,MAAM,WAAW,CAAC;AACtG,OAAO,EAAE,eAAe,EAAuC,MAAM,UAAU,CAAC;AAChF,OAAO,EAAE,aAAa,EAAE,kBAAkB,EAAkB,MAAM,UAAU,CAAC;AAE7E,OAAO,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AACpD,OAAO,EAAE,IAAI,EAAiE,MAAM,WAAW,CAAC;AAChG,OAAO,EACL,oBAAoB,EACpB,kCAAkC,GAInC,MAAM,iBAAiB,CAAC"}

package/dist/pool.d.ts

@@ -0,0 +1,123 @@
+import { Identity } from "./identity.js";
+import type { PubsubEvent } from "./pubsub.js";
+import { type JsonValue } from "./rpc.js";
+/** One configured connection target. */
+export interface Seed {
+    host: string;
+    port: number;
+}
+export interface PoolOptions {
+    /** How many currently-live control links a publish() fans out to
+     * before resolving -- partial success counts as success, matching
+     * macula_client:publish/5's own documented semantics. Default 1.
+     * NOT YET FULLY AT PARITY above 1: the Erlang reference stamps ONE
+     * seq across every replica specifically so a receiver's own
+     * (publisher, seq, topic) dedup collapses the redundant copies into
+     * one event. This SDK's Session.publish() has no caller-supplied-seq
+     * parameter to do the same (each call mints its own fresh seq), so
+     * setting this above 1 would deliver N distinct, non-deduplicable
+     * copies to every subscriber -- clamped to 1 until that's fixed. */
+    replicationFactor?: number;
+    /** How long a recorded (realm, publisher, seq, topic) key is treated
+     * as a duplicate before it ages out. Default 60_000, matching the
+     * Erlang reference's own `dedup_window_ms` default. */
+    dedupWindowMs?: number;
+    /** How often the dedup table is swept for expired entries. Default
+     * 30_000, matching the Erlang reference's own `dedup_sweep_ms`. */
+    dedupSweepMs?: number;
+    /** How often a live control link is health-checked (see
+     * #armHealthCheck's own doc for why publish() alone can't be trusted
+     * to ever notice a dead connection). Default 10_000. */
+    healthCheckIntervalMs?: number;
+}
+export interface PoolStatus {
+    /** Seeds whose control link is currently connected. */
+    healthyLinks: number;
+    /** Seeds whose control link is not currently connected (connecting
+     * or backing off). Every configured seed is exactly one or the
+     * other -- a link backs off and retries forever, it is never given
+     * up on and dropped from the pool, same as the Erlang reference. */
+    failedLinks: number;
+}
+/** Thrown by publish()/call() when the pool has zero live control links
+ * to try -- a distinct, identifiable condition from any one link's own
+ * transient error, matching macula_client:publish/5's own `{error,
+ * {transient, no_healthy_station}}`. */
+export declare class NoHealthyStationError extends Error {
+    constructor();
+}
+/**
+ * A resilient multi-station client: live connections to every configured
+ * seed held concurrently, each independently monitored and respawned
+ * with backoff on disconnect, every tracked subscription re-established
+ * automatically when its own link reconnects. See this module's own
+ * header doc for the full design, why a "link" is a small role-scoped
+ * session set rather than one Session, and its one deliberate deviation
+ * from the Erlang reference (topic-scoped dedup).
+ */
+export declare class Pool {
+    #private;
+    private constructor();
+    /** Dials the control role against every seed concurrently under
+     * `controlIdentity` (the caller's own identity -- publish()/call()
+     * are attributed to it on the wire) and resolves once every seed's
+     * FIRST connect attempt has settled (success or a logged failure
+     * headed into backoff) -- matches tapRoom()'s own "await the first
+     * attempt, not the eventual outcome" reasoning (macula-mcp's
+     * lobby_observer.ts): a caller that publishes/calls immediately
+     * after connect() must not race links still mid-handshake. */
+    static connect(seeds: Seed[], controlIdentity: Identity, opts?: PoolOptions): Promise<Pool>;
+    /** Publishes to `replicationFactor` currently-live control links
+     * (default 1); partial success counts as success. A link whose
+     * publish attempt fails is marked for respawn immediately -- this is
+     * this v1's only liveness signal for the control role, since it
+     * cannot also carry a liveness-only subscribe (see this module's own
+     * header doc). Throws NoHealthyStationError if zero links are live. */
+    publish(realm: string | undefined, topic: string, payload: JsonValue, opts?: {
+        ttlMs?: number;
+    }): Promise<void>;
+    /** Calls `procedure` against the pool's live control links in order
+     * until one succeeds or all have been tried. Throws
+     * NoHealthyStationError if zero links are live.
+     *
+     * A `MaculaCallError` (a real BOLT#4 response -- e.g.
+     * unknown_next_peer, unauthorized) does NOT mark its link for
+     * respawn: the connection plainly worked, it answered. Found in
+     * review 2026-09-05: treating every thrown error as evidence of a
+     * dead connection meant a single genuinely-answered error (a
+     * procedure nobody serves, a bad realm, a gated call this identity
+     * isn't authorized for) tore down and reconnected EVERY live control
+     * link in turn as call() moved through them re-trying the same
+     * doomed call -- and for a non-idempotent provider handler, actually
+     * re-invoked it on each one. Only an error that never got a
+     * wire-level answer at all (the same distinction call()'s own doc on
+     * Session draws) is treated as a dead link. Each link's own `session`
+     * reference is re-checked before scheduling a reconnect, in case a
+     * concurrent operation already superseded it between this loop
+     * starting and this iteration running. */
+    call(realm: string | undefined, procedure: string, payload: JsonValue, opts?: {
+        deadlineMs?: number;
+    }): Promise<JsonValue>;
+    /** Subscribes `handler` to `(realm, topic)`: opens one subscribe-only
+     * session against every configured seed, replayed automatically on
+     * every future respawn. Mints a dedicated identity for this topic by
+     * default (disposed on unsubscribe); pass `identity` to supply the
+     * pool's own instead (e.g. for a stable, caller-controlled identity
+     * across restarts, matching macula-mcp's own observeRoomIdentityPath
+     * pattern) -- the pool never disposes an identity it didn't mint.
+     * Returns an unsubscribe function. */
+    subscribe(realm: string | undefined, topic: string, handler: (evt: PubsubEvent) => void, identity?: Identity): Promise<() => Promise<void>>;
+    /** Live/backing-off CONTROL link counts (publish/call reachability).
+     * Every configured seed is exactly one or the other. Per-topic
+     * subscription link health is not reflected here -- inspect a
+     * specific subscription's own behavior (events arriving or not)
+     * instead; exposing N independent per-topic health vectors here
+     * would not simplify what a caller actually needs to know. */
+    status(): PoolStatus;
+    /** Closes every control and subscription link and disposes every
+     * identity this pool owns (the caller-supplied control identity
+     * included). Awaits each link's in-flight connect/reconnect first,
+     * so a still-connecting link never has its identity yanked out from
+     * under it. */
+    close(): Promise<void>;
+}

package/dist/pool.js

@@ -0,0 +1,538 @@
+// Resilient multi-station client -- ports macula/src/client/macula_client.erl's
+// pool design (N live links, monitor + respawn-with-backoff, subscription
+// replay on reconnect) into this SDK. `Session` (session.ts) and
+// `connectWithFallback`/`withSession` (this SDK's consumers, e.g.
+// macula-mcp's macula_ts_client.ts) are both dial-one-then-use primitives --
+// correct for a one-shot operation, wrong for anything that needs to stay
+// reachable across a station's own outage. A Pool holds live connections to
+// every configured seed concurrently, not one-then-fallback-on-first-failure;
+// a seed that never connects and a link whose connection later dies are the
+// same condition (backoff, retry forever) rather than two different code
+// paths.
+//
+// == Why this isn't "one Session per seed" ==
+//
+// Erlang's macula_client can put N tracked (Realm, Topic) subscriptions
+// (plus Call, plus Advertise) on ONE gen_server-owned link, because a BEAM
+// mailbox demuxes every message type for that one process regardless of how
+// many concerns it's juggling. This SDK's Session has no equivalent: its
+// underlying control stream supports exactly one concurrent reader --
+// `subscribe()` throws outright if called twice on the same Session
+// ("a second concurrent subscribe() on the same Session races; open a
+// second Session instead"), and `call()`/`serve()` are mutually exclusive
+// with an active subscribe on the same Session for the identical reason
+// (macula-go's FrameStream does a raw sequential read into a shared buffer,
+// no per-caller demux). Confirmed live 2026-09-04 while porting the Go side
+// of this same design: this is a wire-level constraint, not a TS-specific
+// gap -- macula-mcp already works around it today by giving lobby_observer.ts
+// a dedicated identity+Session PER ROOM TOPIC rather than multiplexing one
+// connection.
+//
+// So a "link" to one station here is a small SET of role-scoped sessions,
+// not one session:
+//   - one "control" session (this pool's own caller-supplied identity),
+//     used for publish() and call() and NEVER subscribed on -- publish() is
+//     write-only (explicitly unguarded by the exclusivity rule) and call()'s
+//     own internal queue already serialises concurrent calls safely, so one
+//     control session per station is enough regardless of call volume.
+//   - one additional session PER CURRENTLY-TRACKED TOPIC, under an identity
+//     derived from that topic (shared across every station's copy of that
+//     topic's session -- reused across stations is safe, since a station's
+//     own per-identity dedupe only kicks a SECOND connection to THAT SAME
+//     station, never across different stations). Each does exactly one
+//     subscribe() and nothing else.
+// Every one of these sessions is independently monitored and respawned with
+// backoff; a topic session dying just re-subscribes its own one topic on
+// respawn (no "replay N subscriptions onto a survivor" step needed, since
+// each session only ever carried one). A control link can't also carry a
+// liveness-only subscribe without reintroducing the exclusivity problem it
+// exists to avoid, and a failed call() genuinely does surface a dead
+// connection -- but publish() does not: found live 2026-09-04 that a
+// publish() attempt on a session the station had already kicked can still
+// locally "succeed" (the frame is handed off before the QUIC stack notices
+// its own connection is gone), so a publish-only workload could go
+// arbitrarily long without ever discovering a dead control link. Every
+// live control link is therefore also health-checked on a timer
+// (#armHealthCheck's own doc has the mechanism) -- a periodic call() to a
+// procedure name guaranteed never to be advertised, whose failure is
+// inspected to tell "a real BOLT#4 unknown_next_peer came back" (alive)
+// apart from "this never reached anyone at all" (dead, reconnect).
+//
+// == Deliberate deviation from the Erlang reference ==
+//
+// macula_client's own inbound-event dedup keys on (Realm, Publisher, Seq)
+// alone, with no Topic. That is the exact shape of a real bug found and
+// fixed on the station side 2026-09-04 (macula-station's event_dedup): an
+// identity's own auto-published facts and its application-level publishes
+// can share one seq-counter space, and two different topics publishing the
+// same seq collide under a topic-blind key. This pool's own dedup includes
+// Topic from the start.
+import { Identity } from "./identity.js";
+import { MaculaCallError } from "./rpc.js";
+import { Session } from "./session.js";
+/** Thrown by publish()/call() when the pool has zero live control links
+ * to try -- a distinct, identifiable condition from any one link's own
+ * transient error, matching macula_client:publish/5's own `{error,
+ * {transient, no_healthy_station}}`. */
+export class NoHealthyStationError extends Error {
+    constructor() {
+        super("macula-ts: pool has no currently-live links");
+        this.name = "NoHealthyStationError";
+    }
+}
+const RECONNECT_BASE_MS = 1_000;
+const RECONNECT_MAX_MS = 30_000;
+/** How often a LIVE control link is health-checked (see #armHealthCheck's
+ * own doc for why publish() alone can't be trusted to ever notice a dead
+ * connection). Topic-role links need no equivalent -- their own
+ * subscribe() already gives them a real, immediate onClosed signal. */
+const HEALTH_CHECK_INTERVAL_MS = 10_000;
+function subKey(realm, topic) {
+    return `${realm ?? ""}\0${topic}`;
+}
+function dedupKey(realm, publisher, seq, topic) {
+    return `${realm ?? ""}\0${Buffer.from(publisher).toString("hex")}\0${seq}\0${topic}`;
+}
+/**
+ * A resilient multi-station client: live connections to every configured
+ * seed held concurrently, each independently monitored and respawned
+ * with backoff on disconnect, every tracked subscription re-established
+ * automatically when its own link reconnects. See this module's own
+ * header doc for the full design, why a "link" is a small role-scoped
+ * session set rather than one Session, and its one deliberate deviation
+ * from the Erlang reference (topic-scoped dedup).
+ */
+export class Pool {
+    #controlIdentity;
+    #controlLinks;
+    #seeds;
+    #subscriptions = new Map();
+    #dedup = new Map();
+    #sweepTimer;
+    #replicationFactor;
+    #dedupWindowMs;
+    #healthCheckIntervalMs;
+    #closed = false;
+    constructor(controlIdentity, seeds, opts) {
+        this.#controlIdentity = controlIdentity;
+        this.#seeds = seeds;
+        const requestedReplication = opts.replicationFactor ?? 1;
+        if (requestedReplication !== 1) {
+            console.error(`macula-ts pool: replicationFactor ${requestedReplication} is not yet supported (each replica would publish ` +
+                "a distinct seq, so a receiver's dedup can't collapse them into one event) -- clamping to 1.");
+        }
+        this.#replicationFactor = 1;
+        this.#dedupWindowMs = opts.dedupWindowMs ?? 60_000;
+        this.#healthCheckIntervalMs = opts.healthCheckIntervalMs ?? HEALTH_CHECK_INTERVAL_MS;
+        this.#controlLinks = seeds.map((seed) => this.#newRoleLink(seed, controlIdentity, undefined));
+        const sweepMs = opts.dedupSweepMs ?? 30_000;
+        this.#sweepTimer = setInterval(() => this.#sweepDedup(), sweepMs);
+        this.#sweepTimer.unref?.();
+    }
+    #newRoleLink(seed, identity, onConnected) {
+        return {
+            seed,
+            identity,
+            session: undefined,
+            status: "connecting",
+            reconnectAttempt: 0,
+            retryTimer: undefined,
+            healthCheckTimer: undefined,
+            closing: false,
+            inFlight: undefined,
+            onConnected,
+            closedDuringConnect: false,
+        };
+    }
+    /** Dials the control role against every seed concurrently under
+     * `controlIdentity` (the caller's own identity -- publish()/call()
+     * are attributed to it on the wire) and resolves once every seed's
+     * FIRST connect attempt has settled (success or a logged failure
+     * headed into backoff) -- matches tapRoom()'s own "await the first
+     * attempt, not the eventual outcome" reasoning (macula-mcp's
+     * lobby_observer.ts): a caller that publishes/calls immediately
+     * after connect() must not race links still mid-handshake. */
+    static async connect(seeds, controlIdentity, opts = {}) {
+        if (seeds.length === 0)
+            throw new Error("macula-ts: Pool.connect() needs at least one seed");
+        const seen = new Set();
+        for (const seed of seeds) {
+            const seedKey = `${seed.host}:${seed.port}`;
+            if (seen.has(seedKey))
+                throw new Error(`macula-ts: Pool.connect() given duplicate seed ${seedKey} -- each seed must be a distinct station`);
+            seen.add(seedKey);
+        }
+        const pool = new Pool(controlIdentity, seeds, opts);
+        await Promise.all(pool.#controlLinks.map((link) => pool.#attach(link)));
+        return pool;
+    }
+    async #attach(link) {
+        const attempt = this.#attachOnce(link);
+        link.inFlight = attempt.finally(() => {
+            if (link.inFlight === attempt)
+                link.inFlight = undefined;
+        });
+        await link.inFlight;
+    }
+    /** (Re)connects one role link and, for a topic role, re-subscribes it.
+     * Never throws -- a failure logs and schedules a backoff retry, the
+     * same self-healing shape every persistent connection in this
+     * ecosystem already uses. */
+    async #attachOnce(link) {
+        if (link.closing)
+            return;
+        // Defensive: a redundant call on an already-live link must never
+        // overwrite its session with a second connection under the same
+        // identity to the same station (exactly the collision this whole
+        // design exists to avoid). #scheduleReconnect's own idempotency
+        // guard is what should prevent this from ever being reachable in
+        // practice; this is the belt-and-suspenders backstop.
+        if (link.session)
+            return;
+        link.status = "connecting";
+        let session;
+        try {
+            session = await Session.connect(link.seed.host, link.seed.port, link.identity);
+        }
+        catch (err) {
+            console.error(`macula-ts pool: connect to ${link.seed.host}:${link.seed.port} failed:`, err);
+            this.#scheduleReconnect(link);
+            return;
+        }
+        if (link.closing) {
+            await session.close(link.identity).catch(() => { });
+            return;
+        }
+        if (link.onConnected) {
+            link.closedDuringConnect = false;
+            try {
+                await link.onConnected(link, session);
+            }
+            catch (err) {
+                console.error(`macula-ts pool: subscribe on ${link.seed.host}:${link.seed.port} failed:`, err);
+                await session.close(link.identity).catch(() => { });
+                this.#scheduleReconnect(link);
+                return;
+            }
+            if (link.closedDuringConnect) {
+                console.error(`macula-ts pool: ${link.seed.host}:${link.seed.port}'s subscription closed before it could be marked live -- retrying`);
+                await session.close(link.identity).catch(() => { });
+                this.#scheduleReconnect(link);
+                return;
+            }
+        }
+        link.session = session;
+        link.status = "live";
+        link.reconnectAttempt = 0;
+        if (!link.onConnected)
+            this.#armHealthCheck(link);
+    }
+    /** Control-role links only (topic roles have their own subscribe()
+     * onClosed and never reach here -- `!link.onConnected` is what
+     * distinguishes them). publish() is fire-and-forget: found live
+     * 2026-09-04 that a publish() attempt on a session the station had
+     * already kicked can still locally "succeed" (the frame is handed off
+     * before the QUIC stack notices its own connection is gone), so a
+     * publish-only caller could go arbitrarily long without this pool
+     * ever discovering a dead control link. Every HEALTH_CHECK_INTERVAL_MS
+     * while the link is live, this calls a procedure name that is
+     * guaranteed never to be advertised (a fresh UUID-shaped string) and
+     * inspects the failure: a clean MaculaCallError means a real BOLT#4
+     * response came back over the wire (unknown_next_peer, as expected) --
+     * the connection is genuinely alive, nothing to do. Any OTHER
+     * thrown error means the call never got a wire-level answer at all --
+     * the same signal call()'s own doc uses to distinguish a real BOLT#4
+     * answer from "this never reached anyone" -- so it's treated exactly
+     * like a real operation failure and schedules a reconnect. */
+    #armHealthCheck(link) {
+        if (link.healthCheckTimer)
+            clearInterval(link.healthCheckTimer);
+        const timer = setInterval(() => {
+            const session = link.session;
+            if (!session)
+                return;
+            const probe = `_pool.healthcheck.${Math.random().toString(36).slice(2)}`;
+            session.call(probe, null, { deadlineMs: this.#healthCheckIntervalMs }).then(() => {
+                // A real provider somehow answering a random UUID-shaped
+                // procedure name is astronomically unlikely and not itself a
+                // problem either way -- the connection is clearly alive.
+            }, (err) => {
+                if (err instanceof MaculaCallError)
+                    return; // alive: a real wire answer came back
+                if (link.session !== session)
+                    return; // already superseded by a reconnect
+                console.error(`macula-ts pool: health check on ${link.seed.host}:${link.seed.port} failed:`, err);
+                this.#scheduleReconnect(link);
+            });
+        }, this.#healthCheckIntervalMs);
+        timer.unref?.();
+        link.healthCheckTimer = timer;
+    }
+    /** Marks `link` for backoff and schedules its next reconnect attempt.
+     * Closes whatever session it currently holds first (fire-and-forget,
+     * not awaited -- the retry timer must not wait on a graceful close
+     * round trip) so a still-alive session from an OPERATION failure
+     * (publish()/call() throwing for a reason that doesn't mean the
+     * connection itself already died, unlike a subscribe onClosed) is
+     * never simply orphaned. Found live 2026-09-04: without this, a
+     * publish/call failure left the old session's native handle both
+     * leaked AND, worse, still open under this link's identity -- the
+     * NEXT connect attempt for this SAME station under that SAME
+     * identity then races the still-live old one for the station's own
+     * per-identity dedupe kick, with no guarantee which one loses. The
+     * close is fired here, before scheduling, so it has the full backoff
+     * delay (at least RECONNECT_BASE_MS) to land before a new connect
+     * attempt begins.
+     *
+     * Idempotent per backoff episode: a no-op once `link.status` is
+     * already "backoff". Found live in review 2026-09-05: concurrent
+     * operations queued on one session (e.g. several call()s serialised
+     * by Session's own internal queue) can ALL fail once that session
+     * dies, and each one's catch handler calls this -- without this
+     * guard, every failure past the first would re-close an
+     * already-`undefined` `link.session` (harmless) but ALSO arm a
+     * second, third, ... retryTimer, each bumping reconnectAttempt
+     * independently, leaving multiple redundant reconnects racing each
+     * other. Deliberately NOT guarded against "connecting" -- this is
+     * also called from `#attachOnce`'s own failure paths, while status
+     * is still "connecting" from the top of that same function, and
+     * that path must proceed normally. */
+    #scheduleReconnect(link) {
+        if (link.closing)
+            return;
+        if (link.status === "backoff")
+            return;
+        if (link.healthCheckTimer) {
+            clearInterval(link.healthCheckTimer);
+            link.healthCheckTimer = undefined;
+        }
+        const stale = link.session;
+        link.status = "backoff";
+        link.session = undefined;
+        if (stale)
+            void stale.close(link.identity).catch(() => { });
+        const delay = Math.min(RECONNECT_MAX_MS, RECONNECT_BASE_MS * 2 ** link.reconnectAttempt);
+        link.reconnectAttempt += 1;
+        const timer = setTimeout(() => {
+            const attempt = this.#attachOnce(link);
+            link.inFlight = attempt.finally(() => {
+                if (link.inFlight === attempt)
+                    link.inFlight = undefined;
+            });
+        }, delay);
+        // Deliberately NOT unref()'d, unlike healthCheckTimer/sweepTimer --
+        // this pool's own documented contract is "retry forever" for a
+        // link in backoff. Found live in review 2026-09-05: a pure
+        // subscribe()-only process (no other keep-alive handle: no HTTP
+        // listener, no stdio transport) would otherwise exit cleanly the
+        // moment its last live connection drops, silently breaking that
+        // promise instead of actually retrying through the outage.
+        link.retryTimer = timer;
+    }
+    #sweepDedup() {
+        const cutoff = Date.now() - this.#dedupWindowMs;
+        for (const [key, at] of this.#dedup) {
+            if (at < cutoff)
+                this.#dedup.delete(key);
+        }
+    }
+    #liveControlLinks() {
+        return this.#controlLinks.filter((l) => l.status === "live" && l.session);
+    }
+    /** Refuses an `identity` that would double-connect to the same
+     * station as the control role or another already-tracked
+     * subscription -- the station kicks the OLDER of the two, this pool
+     * reconnects it, which gets IT kicked in turn: a perpetual ping-pong
+     * with no error naming the cause. Compares raw node-id bytes, not
+     * object identity, so two separately-loaded Identity instances over
+     * the SAME underlying keypair are still caught. */
+    #assertIdentityNotAlreadyUsed(identity) {
+        const nodeIdHex = Buffer.from(identity.nodeId).toString("hex");
+        if (nodeIdHex === Buffer.from(this.#controlIdentity.nodeId).toString("hex")) {
+            throw new Error("macula-ts pool: this identity is already the pool's own control identity -- reusing it for a subscription would double-connect one identity to one station");
+        }
+        for (const sub of this.#subscriptions.values()) {
+            if (Buffer.from(sub.identity.nodeId).toString("hex") === nodeIdHex) {
+                throw new Error(`macula-ts pool: this identity is already used by the "${sub.topic}" subscription -- reusing it here would double-connect one identity to one station`);
+            }
+        }
+    }
+    /** Publishes to `replicationFactor` currently-live control links
+     * (default 1); partial success counts as success. A link whose
+     * publish attempt fails is marked for respawn immediately -- this is
+     * this v1's only liveness signal for the control role, since it
+     * cannot also carry a liveness-only subscribe (see this module's own
+     * header doc). Throws NoHealthyStationError if zero links are live. */
+    async publish(realm, topic, payload, opts = {}) {
+        if (this.#closed)
+            throw new Error("macula-ts pool: used after close()");
+        const targets = this.#liveControlLinks().slice(0, this.#replicationFactor);
+        if (targets.length === 0)
+            throw new NoHealthyStationError();
+        const results = await Promise.allSettled(targets.map(async (link) => {
+            const session = link.session;
+            if (link.status !== "live" || !session)
+                throw new NoHealthyStationError(); // superseded since targets was captured
+            try {
+                await session.publish(topic, payload, { realm, ttlMs: opts.ttlMs });
+            }
+            catch (err) {
+                if (link.session === session)
+                    this.#scheduleReconnect(link);
+                throw err;
+            }
+        }));
+        if (!results.some((r) => r.status === "fulfilled")) {
+            const first = results.find((r) => r.status === "rejected");
+            throw first ? first.reason : new Error("macula-ts pool: publish failed on every targeted link");
+        }
+    }
+    /** Calls `procedure` against the pool's live control links in order
+     * until one succeeds or all have been tried. Throws
+     * NoHealthyStationError if zero links are live.
+     *
+     * A `MaculaCallError` (a real BOLT#4 response -- e.g.
+     * unknown_next_peer, unauthorized) does NOT mark its link for
+     * respawn: the connection plainly worked, it answered. Found in
+     * review 2026-09-05: treating every thrown error as evidence of a
+     * dead connection meant a single genuinely-answered error (a
+     * procedure nobody serves, a bad realm, a gated call this identity
+     * isn't authorized for) tore down and reconnected EVERY live control
+     * link in turn as call() moved through them re-trying the same
+     * doomed call -- and for a non-idempotent provider handler, actually
+     * re-invoked it on each one. Only an error that never got a
+     * wire-level answer at all (the same distinction call()'s own doc on
+     * Session draws) is treated as a dead link. Each link's own `session`
+     * reference is re-checked before scheduling a reconnect, in case a
+     * concurrent operation already superseded it between this loop
+     * starting and this iteration running. */
+    async call(realm, procedure, payload, opts = {}) {
+        if (this.#closed)
+            throw new Error("macula-ts pool: used after close()");
+        const targets = this.#liveControlLinks();
+        if (targets.length === 0)
+            throw new NoHealthyStationError();
+        let lastErr;
+        for (const link of targets) {
+            const session = link.session;
+            if (link.status !== "live" || !session)
+                continue; // superseded since `targets` was captured
+            try {
+                return await session.call(procedure, payload, { realm, deadlineMs: opts.deadlineMs });
+            }
+            catch (err) {
+                lastErr = err;
+                if (!(err instanceof MaculaCallError) && link.session === session)
+                    this.#scheduleReconnect(link);
+            }
+        }
+        throw lastErr;
+    }
+    /** Subscribes `handler` to `(realm, topic)`: opens one subscribe-only
+     * session against every configured seed, replayed automatically on
+     * every future respawn. Mints a dedicated identity for this topic by
+     * default (disposed on unsubscribe); pass `identity` to supply the
+     * pool's own instead (e.g. for a stable, caller-controlled identity
+     * across restarts, matching macula-mcp's own observeRoomIdentityPath
+     * pattern) -- the pool never disposes an identity it didn't mint.
+     * Returns an unsubscribe function. */
+    async subscribe(realm, topic, handler, identity) {
+        if (this.#closed)
+            throw new Error("macula-ts pool: used after close()");
+        const key = subKey(realm, topic);
+        if (this.#subscriptions.has(key))
+            throw new Error(`macula-ts pool: already subscribed to ${topic}${realm ? ` (realm ${realm})` : ""}`);
+        if (identity)
+            this.#assertIdentityNotAlreadyUsed(identity);
+        const ownsIdentity = identity === undefined;
+        const subIdentity = identity ?? Identity.generate();
+        const sub = { realm, topic, handler, identity: subIdentity, ownsIdentity, links: [] };
+        const onConnected = async (link, session) => {
+            await session.subscribe(topic, (evt) => {
+                const dkey = dedupKey(realm, evt.publisher, evt.seq, topic);
+                if (this.#dedup.has(dkey))
+                    return;
+                this.#dedup.set(dkey, Date.now());
+                sub.handler(evt);
+            }, {
+                realm,
+                onClosed: (err) => {
+                    if (link.session === session) {
+                        console.error(`macula-ts pool: subscription to ${topic} on ${link.seed.host}:${link.seed.port} dropped (${err.message}) -- reconnecting`);
+                        this.#scheduleReconnect(link);
+                    }
+                    else {
+                        // subscribe-start hasn't resolved on this side yet (or
+                        // this link has already moved on) -- flag it so
+                        // #attachOnce notices once `onConnected` itself returns,
+                        // rather than marking a link live with a subscription
+                        // that already silently died. See closedDuringConnect's
+                        // own doc.
+                        link.closedDuringConnect = true;
+                    }
+                },
+            });
+        };
+        sub.links = this.#seeds.map((seed) => this.#newRoleLink(seed, subIdentity, onConnected));
+        this.#subscriptions.set(key, sub);
+        await Promise.all(sub.links.map((link) => this.#attach(link)));
+        return async () => {
+            const tracked = this.#subscriptions.get(key);
+            if (!tracked)
+                return;
+            this.#subscriptions.delete(key);
+            await Promise.all(tracked.links.map(async (link) => {
+                link.closing = true;
+                if (link.retryTimer)
+                    clearTimeout(link.retryTimer);
+                if (link.inFlight)
+                    await link.inFlight.catch(() => { });
+                if (link.session)
+                    await link.session.close(link.identity).catch(() => { });
+            }));
+            if (tracked.ownsIdentity)
+                tracked.identity.dispose();
+        };
+    }
+    /** Live/backing-off CONTROL link counts (publish/call reachability).
+     * Every configured seed is exactly one or the other. Per-topic
+     * subscription link health is not reflected here -- inspect a
+     * specific subscription's own behavior (events arriving or not)
+     * instead; exposing N independent per-topic health vectors here
+     * would not simplify what a caller actually needs to know. */
+    status() {
+        const healthy = this.#liveControlLinks().length;
+        return { healthyLinks: healthy, failedLinks: this.#controlLinks.length - healthy };
+    }
+    /** Closes every control and subscription link and disposes every
+     * identity this pool owns (the caller-supplied control identity
+     * included). Awaits each link's in-flight connect/reconnect first,
+     * so a still-connecting link never has its identity yanked out from
+     * under it. */
+    async close() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        clearInterval(this.#sweepTimer);
+        const allLinks = [...this.#controlLinks, ...[...this.#subscriptions.values()].flatMap((s) => s.links)];
+        await Promise.all(allLinks.map(async (link) => {
+            link.closing = true;
+            if (link.retryTimer)
+                clearTimeout(link.retryTimer);
+            if (link.healthCheckTimer)
+                clearInterval(link.healthCheckTimer);
+            if (link.inFlight)
+                await link.inFlight.catch(() => { });
+            if (link.session)
+                await link.session.close(link.identity).catch(() => { });
+            link.session = undefined;
+            link.status = "backoff"; // reflects reality for status()/#liveControlLinks() if either is called after close()
+        }));
+        for (const sub of this.#subscriptions.values())
+            if (sub.ownsIdentity)
+                sub.identity.dispose();
+        this.#subscriptions.clear();
+        this.#controlIdentity.dispose();
+    }
+}
+//# sourceMappingURL=pool.js.map

package/dist/pool.js.map

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@macula-io/ts",
-  "version": "0.13.5",
+  "version": "0.14.0",
   "description": "TypeScript SDK for the Macula mesh (FFI over macula-go)",
   "license": "Apache-2.0",
   "keywords": [
@@ -46,7 +46,7 @@
     "build:prebuilds": "npm run build:go && prebuildify --napi --strip && npm pkg delete scripts.install",
     "build": "npm run build:addon:dev && tsc",
     "test": "vitest run",
-    "test:live": "MACULA_TS_LIVE=1 vitest run src/session.live.test.ts src/rpc.live.test.ts src/dht.live.test.ts src/pubsub.live.test.ts src/content.live.test.ts src/ucan.live.test.ts src/directdial.live.test.ts",
+    "test:live": "MACULA_TS_LIVE=1 vitest run src/session.live.test.ts src/rpc.live.test.ts src/dht.live.test.ts src/pubsub.live.test.ts src/content.live.test.ts src/ucan.live.test.ts src/directdial.live.test.ts src/pool.live.test.ts",
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {