@layr8/sdk 0.1.0

package/README.md

@@ -0,0 +1,582 @@
+# Layr8 Node.js SDK
+
+The official Node.js SDK for building agents on the [Layr8](https://layr8.com) platform. Agents connect to Layr8 cloud-nodes via WebSocket and exchange [DIDComm v2](https://identity.foundation/didcomm-messaging/spec/) messages with other agents across the network.
+
+## Installation
+
+```bash
+npm install @layr8/sdk
+```
+
+Requires Node.js 20 or later. The package is ESM-only (`"type": "module"`).
+
+## Quick Start
+
+```typescript
+import { Layr8Client, unmarshalBody, logErrors } from "@layr8/sdk";
+import type { Message } from "@layr8/sdk";
+
+interface EchoRequest {
+  message: string;
+}
+
+const client = new Layr8Client(logErrors(), {
+  nodeUrl: "ws://localhost:4000/plugin_socket/websocket",
+  apiKey: "your-api-key",
+  agentDid: "did:web:myorg:my-agent",
+});
+
+client.handle(
+  "https://layr8.io/protocols/echo/1.0/request",
+  async (msg: Message): Promise<Message | null> => {
+    const body = unmarshalBody<EchoRequest>(msg as any);
+    return {
+      id: "",
+      type: "https://layr8.io/protocols/echo/1.0/response",
+      from: "",
+      to: [],
+      threadId: "",
+      parentThreadId: "",
+      body: { echo: body.message },
+    };
+  },
+);
+
+await client.connect();
+console.log(`agent running as ${client.did}`);
+
+process.on("SIGINT", async () => {
+  await client.close();
+  process.exit(0);
+});
+```
+
+## Core Concepts
+
+### Client
+
+The `Layr8Client` is the main entry point. It manages the WebSocket connection to a cloud-node, routes inbound messages to handlers, and provides methods for sending outbound messages.
+
+```typescript
+const client = new Layr8Client(logErrors(), {...});
+
+// Register handlers before connecting
+client.handle(messageType, handlerFn);
+
+// Connect to the cloud-node
+await client.connect();
+```
+
+### Messages
+
+`Message` represents a DIDComm v2 message with standard fields:
+
+```typescript
+interface Message {
+  id: string;             // unique message ID (auto-generated if empty)
+  type: string;           // DIDComm message type URI
+  from: string;           // sender DID (auto-filled from client)
+  to: string[];           // recipient DIDs
+  threadId: string;       // thread correlation ID
+  parentThreadId: string; // parent thread for nested conversations
+  body: unknown;          // message payload (serialized to JSON)
+  context?: MessageContext; // cloud-node metadata (inbound only)
+}
+```
+
+Decode the body of an inbound message with `unmarshalBody`:
+
+```typescript
+const req = unmarshalBody<MyRequest>(msg as any);
+```
+
+### Handlers
+
+Handlers process inbound messages. Register them with `client.handle()` before calling `connect()`.
+
+A handler receives a `Message` and returns:
+
+| Return value | Behavior |
+|---|---|
+| `Message` | Sends response to the sender. `from`, `to`, and `threadId` are auto-filled. |
+| `null` | Fire-and-forget — no response sent. |
+| Thrown error | Sends a DIDComm [problem report](https://identity.foundation/didcomm-messaging/spec/#problem-reports) to the sender. |
+
+```typescript
+client.handle(
+  "https://layr8.io/protocols/echo/1.0/request",
+  async (msg: Message): Promise<Message | null> => {
+    const body = unmarshalBody<EchoRequest>(msg as any);
+    return {
+      id: "",
+      type: "https://layr8.io/protocols/echo/1.0/response",
+      from: "",
+      to: [],
+      threadId: "",
+      parentThreadId: "",
+      body: { echo: body.message },
+    };
+  },
+);
+```
+
+#### Protocol Registration
+
+The SDK automatically derives protocol base URIs from your handler message types and registers them with the cloud-node on connect. For example, handling `https://layr8.io/protocols/echo/1.0/request` registers the protocol `https://layr8.io/protocols/echo/1.0`.
+
+## Sending Messages
+
+### Send
+
+Send a one-way message. By default, `send()` waits for the server to acknowledge receipt:
+
+```typescript
+await client.send({
+  type: "https://didcomm.org/basicmessage/2.0/message",
+  to: ["did:web:other-org:their-agent"],
+  body: { content: "hello!" },
+});
+```
+
+`send()` accepts `Partial<Message>` — only `type`, `to`, and `body` are required.
+
+To skip waiting for the server acknowledgment, pass `{ fireAndForget: true }`:
+
+```typescript
+await client.send(
+  {
+    type: "https://didcomm.org/basicmessage/2.0/message",
+    to: ["did:web:other-org:their-agent"],
+    body: { content: "hello!" },
+  },
+  { fireAndForget: true },
+);
+```
+
+#### Send Options
+
+```typescript
+interface SendOptions {
+  fireAndForget?: boolean; // skip waiting for server ack (default: false)
+}
+```
+
+### Request (Request/Response)
+
+Send a message and await a correlated response:
+
+```typescript
+const resp = await client.request(
+  {
+    type: "https://layr8.io/protocols/echo/1.0/request",
+    to: ["did:web:other-org:echo-agent"],
+    body: { message: "ping" },
+  },
+  { signal: AbortSignal.timeout(5_000) },
+);
+
+const result = unmarshalBody<EchoResponse>(resp as any);
+console.log(result.echo); // "ping"
+```
+
+Thread correlation is automatic — the SDK generates a `threadId`, attaches it to the outbound message, and matches the inbound response by the same `threadId`.
+
+#### Request Options
+
+```typescript
+interface RequestOptions {
+  parentThread?: string;  // parent thread ID for nested conversations
+  signal?: AbortSignal;   // abort/timeout control
+}
+```
+
+## Configuration
+
+Configuration can be set explicitly or via environment variables. Environment variables are used as fallbacks when the corresponding field is empty or undefined.
+
+| Field | Environment Variable | Required | Description |
+|---|---|---|---|
+| `nodeUrl` | `LAYR8_NODE_URL` | Yes | WebSocket URL of the cloud-node |
+| `apiKey` | `LAYR8_API_KEY` | Yes | API key for authentication |
+| `agentDid` | `LAYR8_AGENT_DID` | No | Agent DID identity |
+
+If `agentDid` is not provided, the cloud-node creates an ephemeral DID on connect. Retrieve it with `client.did`.
+
+```typescript
+// Explicit configuration
+const client = new Layr8Client(logErrors(), {
+  nodeUrl: "ws://localhost:4000/plugin_socket/websocket",
+  apiKey: "my-api-key",
+  agentDid: "did:web:myorg:my-agent",
+});
+
+// Environment-only configuration
+// Set LAYR8_NODE_URL, LAYR8_API_KEY, LAYR8_AGENT_DID
+const client = new Layr8Client(logErrors());
+```
+
+## Handler Options
+
+### Manual Acknowledgment
+
+By default, messages are acknowledged to the cloud-node before the handler runs (auto-ack). For handlers where you need guaranteed processing, use manual ack to acknowledge only after successful execution. Unacknowledged messages are redelivered by the cloud-node.
+
+```typescript
+import { ack } from "@layr8/sdk";
+
+client.handle(
+  queryType,
+  async (msg: Message): Promise<Message | null> => {
+    const result = await executeQuery(msg);
+    ack(msg as any); // explicitly acknowledge after success
+    return {
+      id: "", type: resultType, from: "", to: [],
+      threadId: "", parentThreadId: "",
+      body: result,
+    };
+  },
+  { manualAck: true },
+);
+```
+
+## Connection Lifecycle
+
+### DID Assignment
+
+If no `agentDid` is configured, the cloud-node assigns an ephemeral DID on connect:
+
+```typescript
+const client = new Layr8Client(logErrors(), {
+  nodeUrl: "ws://localhost:4000/plugin_socket/websocket",
+  apiKey: "my-key",
+});
+await client.connect();
+
+console.log(client.did); // "did:web:myorg:abc123" (assigned by node)
+```
+
+### Connection Resilience
+
+The SDK automatically reconnects when the WebSocket connection drops (e.g., node restart, network interruption). Reconnection uses exponential backoff starting at 1 second, capped at 30 seconds.
+
+During reconnection:
+- `send()`, `request()`, and other operations throw `NotConnectedError` immediately — the SDK does not queue messages
+- The `disconnect` event fires when the connection drops
+- The `reconnect` event fires when the connection is restored
+- `close()` stops the reconnect loop
+
+```typescript
+client.on("disconnect", (err: Error) => {
+  console.log("disconnected:", err.message);
+});
+
+client.on("reconnect", () => {
+  console.log("reconnected");
+});
+```
+
+## Observability Hooks
+
+For tools that need to surface raw DIDComm traffic (debugging, dashboards, MCP-style adapters that expose layr8 to other runtimes), the client emits events for every message it sends or receives. These fire alongside normal dispatch and don't change handler semantics.
+
+```typescript
+client.on("inbound", (msg: Message) => {
+  console.log("← recv", msg.type, "from", msg.from);
+});
+
+client.on("outbound", (msg: Message) => {
+  console.log("→ send", msg.type, "to", msg.to);
+});
+```
+
+`inbound` fires after a message is successfully parsed, before it's routed to a handler or matched to a pending `request()`. `outbound` fires for every `send()`, `request()`, and handler auto-response.
+
+### Default handler for unmatched types
+
+When the cloud-node delivers a message whose type has no specific handler, the default behaviour is to fire `ErrorKind.NoHandler` via your error handler. To route those messages somewhere instead, register a default handler:
+
+```typescript
+client.handleDefault(async (msg: Message) => {
+  console.log("unmatched:", msg.type);
+  return null;
+});
+```
+
+The cloud-node only delivers messages whose **protocol** the client has subscribed to (derived from `handle()` registrations). The default handler catches types within a subscribed protocol that lack a specific handler — it does not cause the client to subscribe to additional protocols.
+
+`handleDefault` runs with auto-ack only; `manualAck` is not supported on the fallback path. Use `handle(type, fn, { manualAck: true })` for types that need durable processing.
+
+## Message Context
+
+Inbound messages include a `context` field with metadata from the cloud-node:
+
+```typescript
+client.handle(messageType, async (msg: Message) => {
+  if (msg.context) {
+    console.log("Recipient:", msg.context.recipient);
+    console.log("Authorized:", msg.context.authorized);
+
+    for (const cred of msg.context.senderCredentials) {
+      console.log(`Sender credential: ${cred.name} (${cred.id})`);
+    }
+  }
+  return null;
+});
+```
+
+| Field | Type | Description |
+|---|---|---|
+| `recipient` | `string` | The DID that received this message |
+| `authorized` | `boolean` | Whether the sender is authorized by the node's policy |
+| `senderCredentials` | `Credential[]` | Verifiable credentials presented by the sender |
+
+## Error Handling
+
+### ErrorHandler (Required)
+
+The `Layr8Client` constructor requires an `ErrorHandler` callback as its first argument. This ensures no SDK errors are silently dropped. The callback receives structured `SDKError` objects for parse failures, unhandled message types, handler exceptions, and server rejections.
+
+```typescript
+import { Layr8Client, logErrors } from "@layr8/sdk";
+import type { ErrorHandler } from "@layr8/sdk";
+
+// Use the built-in logger (writes to console.error)
+const client = new Layr8Client(logErrors(), { ... });
+
+// Or provide a custom handler
+const onError: ErrorHandler = (err) => {
+  metrics.increment(`sdk.error.${err.kind}`);
+  logger.warn("SDK error", {
+    kind: err.kind,
+    messageId: err.messageId,
+    type: err.type,
+    cause: err.cause?.message,
+  });
+};
+const client = new Layr8Client(onError, { ... });
+```
+
+### SDKError
+
+`SDKError` is a structured error report passed to the `ErrorHandler`. It carries machine-readable context about what went wrong:
+
+| Field | Type | Description |
+|---|---|---|
+| `kind` | `ErrorKind` | Category of the error |
+| `messageId` | `string` | ID of the message that caused the error (if available) |
+| `type` | `string` | DIDComm message type (if available) |
+| `from` | `string` | Sender DID (if available) |
+| `cause` | `Error \| null` | Underlying error |
+| `raw` | `unknown` | Raw payload for parse failures |
+| `timestamp` | `Date` | When the error occurred |
+
+### ErrorKind
+
+| Kind | Description |
+|---|---|
+| `ParseFailure` | Inbound message could not be parsed as DIDComm |
+| `NoHandler` | No handler registered for the message type |
+| `HandlerException` | A handler threw an exception |
+| `ServerReject` | The server rejected a sent message |
+| `TransportWrite` | Failed to write to the WebSocket connection |
+
+### logErrors()
+
+`logErrors()` returns a built-in `ErrorHandler` that logs every error to `console.error` with structured metadata. Use it as a sensible default:
+
+```typescript
+import { logErrors } from "@layr8/sdk";
+
+const client = new Layr8Client(logErrors(), { ... });
+```
+
+### Problem Reports
+
+When a handler throws an error, the SDK automatically sends a [DIDComm problem report](https://identity.foundation/didcomm-messaging/spec/#problem-reports) to the sender:
+
+```typescript
+client.handle(msgType, async (msg: Message) => {
+  throw new Error("something went wrong"); // sends problem report
+});
+```
+
+When `request()` receives a problem report as the response, it throws a `ProblemReportError`:
+
+```typescript
+import { ProblemReportError } from "@layr8/sdk";
+
+try {
+  const resp = await client.request(msg);
+} catch (err) {
+  if (err instanceof ProblemReportError) {
+    console.log(`Remote error [${err.code}]: ${err.comment}`);
+  }
+}
+```
+
+### Connection Errors
+
+Connection failures throw a `ConnectionError`:
+
+```typescript
+import { ConnectionError } from "@layr8/sdk";
+
+try {
+  await client.connect();
+} catch (err) {
+  if (err instanceof ConnectionError) {
+    console.log(`Failed to connect to ${err.url}: ${err.reason}`);
+  }
+}
+```
+
+### Error Classes
+
+| Error | Description |
+|---|---|
+| `NotConnectedError` | Operation attempted before `connect()` or after `close()` |
+| `AlreadyConnectedError` | `handle()` called after `connect()` |
+| `ClientClosedError` | `connect()` called on a closed client |
+| `ProblemReportError` | Remote handler returned an error (`.code`, `.comment`) |
+| `ConnectionError` | Failed to connect to cloud-node (`.url`, `.reason`) |
+
+## W3C Verifiable Credentials
+
+The SDK provides methods for signing, verifying, storing, listing, and retrieving [W3C Verifiable Credentials](https://www.w3.org/TR/vc-data-model-2.0/). These operations use the cloud-node's REST API and the DID keys in the node's wallet.
+
+### Sign a Credential
+
+```typescript
+import type { Credential } from "@layr8/sdk";
+
+const cred: Credential = {
+  "@context": ["https://www.w3.org/ns/credentials/v2"],
+  id: "urn:uuid:my-credential",
+  type: ["VerifiableCredential"],
+  issuer: client.did,
+  credentialSubject: { id: "did:web:example:holder", name: "Alice" },
+};
+
+const signedJWT = await client.signCredential(cred);
+```
+
+Options: `{ issuerDid, format }`.
+
+### Verify a Credential
+
+```typescript
+const verified = await client.verifyCredential(signedJWT);
+console.log(verified.credential); // decoded credential claims
+console.log(verified.headers);    // JWT headers (alg, kid, etc.)
+```
+
+Options: `{ verifierDid }`.
+
+> **Note:** The verifier DID must have keys in the local node's wallet. Cross-node verification is not currently supported.
+
+### Store, List, Get
+
+```typescript
+// Store a signed credential
+const stored = await client.storeCredential(signedJWT);
+console.log(stored.id); // storage ID
+
+// List all stored credentials
+const creds = await client.listCredentials();
+
+// Retrieve by ID
+const fetched = await client.getCredential(stored.id);
+console.log(fetched.credential_jwt); // the original signed JWT
+```
+
+Store options: `{ holderDid, issuerDid, validUntil }`.
+List options: `{ holderDid }`.
+
+### Output Formats
+
+The `format` option accepts: `"compact_jwt"` (default), `"json"`, `"jwt"`, `"enveloped"`.
+
+## W3C Verifiable Presentations
+
+Presentations wrap one or more signed credentials into a holder-signed envelope.
+
+### Sign a Presentation
+
+```typescript
+const signedPres = await client.signPresentation([signedJWT], {
+  nonce: "challenge-from-verifier",
+});
+```
+
+Options: `{ holderDid, format, nonce }`.
+
+### Verify a Presentation
+
+```typescript
+const verified = await client.verifyPresentation(signedPres);
+console.log(verified.presentation); // decoded presentation claims
+console.log(verified.headers);      // JWT headers
+```
+
+Options: `{ verifierDid }`.
+
+## Examples
+
+The [examples/](examples/) directory contains complete, runnable agents:
+
+### Echo Agent
+
+A minimal agent that echoes back any message it receives. Demonstrates request/response handlers with auto-ack, auto-thread correlation, and reconnection with backoff.
+
+```bash
+LAYR8_API_KEY=your-key npx tsx examples/echo-agent.ts
+```
+
+### Chat Client
+
+An interactive chat client for DIDComm basic messaging. Demonstrates fire-and-forget `send()`, inbound message handling, `MessageContext` for sender credentials, and multi-recipient messaging.
+
+```bash
+LAYR8_API_KEY=your-key npx tsx examples/chat.ts did:web:friend:chat-agent
+```
+
+### Durable Handler
+
+Persist-then-ack pattern: writes inbound messages to a JSON-lines file before acknowledging. If the process crashes before ack, the cloud-node redelivers. Demonstrates `manualAck` with zero external dependencies.
+
+```bash
+LAYR8_API_KEY=your-key npx tsx examples/durable-handler.ts
+```
+
+## Development
+
+### Prerequisites
+
+- Node.js 20+
+- npm
+
+### Scripts
+
+```bash
+npm test           # Run unit tests (vitest)
+npm run test:watch # Run tests in watch mode
+npm run build      # Compile TypeScript
+```
+
+## Architecture
+
+The SDK is structured around a small set of types:
+
+```
+Layr8Client       → public API (connect, send, request, handle, close)
+  ├── Config      → configuration with env var fallback
+  ├── Message     → DIDComm v2 message envelope
+  ├── Handler     → message type → handler function registry
+  └── Channel     → WebSocket/Phoenix Channel transport
+```
+
+The transport layer implements the Phoenix Channel V2 wire protocol over WebSocket, including join negotiation, heartbeats, and message acknowledgment.
+
+## License
+
+Copyright Layr8 Inc. All rights reserved.

package/dist/backoff.d.ts

@@ -0,0 +1,10 @@
+/** Exponential backoff with a maximum delay. */
+export declare class Backoff {
+    private readonly initial;
+    private readonly max;
+    private current;
+    constructor(initial: number, max: number);
+    next(): number;
+    reset(): void;
+}
+//# sourceMappingURL=backoff.d.ts.map

package/dist/backoff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backoff.d.ts","sourceRoot":"","sources":["../src/backoff.ts"],"names":[],"mappings":"AAAA,gDAAgD;AAChD,qBAAa,OAAO;IAIhB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,GAAG;IAJtB,OAAO,CAAC,OAAO,CAAS;gBAGL,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,MAAM;IAK9B,IAAI,IAAI,MAAM;IAMd,KAAK,IAAI,IAAI;CAGd"}

package/dist/backoff.js

@@ -0,0 +1,20 @@
+/** Exponential backoff with a maximum delay. */
+export class Backoff {
+    initial;
+    max;
+    current;
+    constructor(initial, max) {
+        this.initial = initial;
+        this.max = max;
+        this.current = initial;
+    }
+    next() {
+        const d = Math.min(this.current, this.max);
+        this.current = Math.min(this.current * 2, this.max);
+        return d;
+    }
+    reset() {
+        this.current = this.initial;
+    }
+}
+//# sourceMappingURL=backoff.js.map

package/dist/backoff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"backoff.js","sourceRoot":"","sources":["../src/backoff.ts"],"names":[],"mappings":"AAAA,gDAAgD;AAChD,MAAM,OAAO,OAAO;IAIC;IACA;IAJX,OAAO,CAAS;IAExB,YACmB,OAAe,EACf,GAAW;QADX,YAAO,GAAP,OAAO,CAAQ;QACf,QAAG,GAAH,GAAG,CAAQ;QAE5B,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IACzB,CAAC;IAED,IAAI;QACF,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC;QAC3C,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,GAAG,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC;QACpD,OAAO,CAAC,CAAC;IACX,CAAC;IAED,KAAK;QACH,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;IAC9B,CAAC;CACF"}

package/dist/channel.d.ts

@@ -0,0 +1,88 @@
+import type { DidSpec } from "./config.js";
+/** Server reply received for a tracked message ref. */
+export interface ServerReply {
+    status: string;
+    reason: string;
+}
+export interface ChannelCallbacks {
+    onMessage: (payload: unknown) => void;
+    onDisconnect?: (err: Error) => void;
+    onReconnect?: () => void;
+}
+/**
+ * Phoenix Channel transport over WebSocket.
+ * Implements the same protocol as the Go SDK's phoenixChannel.
+ */
+export declare class PhoenixChannel {
+    private readonly wsUrl;
+    private readonly apiKey;
+    private ws;
+    private refCounter;
+    private joinRef;
+    private readonly topic;
+    private callbacks;
+    private pendingJoinResolve;
+    private closed;
+    private reconnecting;
+    private protocols;
+    private heartbeatTimer;
+    /**
+     * Monotonic timestamp (Date.now()) of the most recently observed inbound
+     * frame — any message, pong, or phx_reply. Used by the Phoenix-level
+     * watchdog in startHeartbeat to detect "TCP healthy but Phoenix Channel
+     * GenServer hung" failures: when the heartbeat tick observes no frames
+     * for HEARTBEAT_MAX_SILENT_MS, it forces a close that the existing
+     * reconnect path picks up.
+     */
+    private lastFrameAt;
+    /**
+     * Timer that periodically emits a WS-level `{:ping, _}` frame. Independent
+     * of the Phoenix heartbeat — covers the TCP / NAT / LB half-dead case
+     * where the connection is unilaterally killed without a FIN.
+     */
+    private wsPingTimer;
+    /**
+     * Timer armed each time we emit a WS ping. Cleared on any inbound frame
+     * (pong, message, phx_reply — anything proves liveness). If it fires we
+     * force-close the WS so the existing reconnect path takes over.
+     */
+    private pongWaitTimer;
+    private assignedDIDVal;
+    private readonly pendingRefs;
+    private static readonly HEARTBEAT_INTERVAL_MS;
+    private static readonly HEARTBEAT_MAX_SILENT_MS;
+    private static readonly WS_PING_INTERVAL_MS;
+    private static readonly WS_PONG_WAIT_MS;
+    private replyProtocolEnabled;
+    private readonly didSpec;
+    constructor(wsUrl: string, apiKey: string, agentDid: string, callbacks: ChannelCallbacks, didSpec?: DidSpec);
+    connect(protocols: string[], signal?: AbortSignal): Promise<void>;
+    private dial;
+    private join;
+    send(event: string, payload: unknown): Promise<ServerReply>;
+    sendFireAndForget(event: string, payload: unknown): void;
+    sendAck(ids: string[]): void;
+    assignedDID(): string;
+    /** Whether the server supports the reply protocol (capability negotiated at join). */
+    replyProtocol(): boolean;
+    close(): void;
+    private setupReadLoop;
+    private handleInbound;
+    private startHeartbeat;
+    /**
+     * WS-level ping every WS_PING_INTERVAL_MS. Cowboy (Phoenix's HTTP/WS
+     * server) auto-pongs at the protocol layer — even if the application
+     * Channel is hung. When the underlying TCP / NAT / LB has silently
+     * dropped the connection, ping write may succeed locally but no pong
+     * comes back; pongWaitTimer fires and we force-close.
+     */
+    private startWsPingLoop;
+    private armPongWait;
+    private disarmPongWait;
+    private stopLivenessTimers;
+    private reconnectLoop;
+    private rejectPendingRefs;
+    private nextRef;
+    private writeMsg;
+}
+//# sourceMappingURL=channel.d.ts.map