@private.me/xbind 1.3.5 → 3.0.0

package/dist-standalone/event-emitter.d.ts

@@ -0,0 +1,395 @@
+/**
+ * @module event-emitter
+ * Type-safe event emitter for xBind agent events.
+ *
+ * Provides event-driven architecture for agent lifecycle events:
+ * - message-sent: Emitted when a message is successfully sent
+ * - message-received: Emitted when a message is received
+ * - key-rotated: Emitted when encryption keys are rotated
+ * - error: Emitted when an error occurs
+ * - connection-status: Emitted when connection state changes
+ */
+import type { Result } from '@private.me/shared';
+import type { AgentMessage } from './agent.js';
+/** Connection status values */
+export type ConnectionStatus = 'connected' | 'disconnected' | 'reconnecting' | 'error';
+/** Event payload types mapped to event names */
+export interface XBindEventMap {
+    'message-sent': MessageSentEvent;
+    'message-received': MessageReceivedEvent;
+    'key-rotated': KeyRotatedEvent;
+    'error': ErrorEvent;
+    'connection-status': ConnectionStatusEvent;
+}
+/** Base event interface with common fields */
+export interface XBindBaseEvent {
+    /** Event type identifier */
+    readonly type: string;
+    /** ISO 8601 timestamp when event was emitted */
+    readonly timestamp: string;
+    /** Unique event identifier for tracking and deduplication */
+    readonly eventId: string;
+}
+/** Emitted when a message is successfully sent */
+export interface MessageSentEvent extends XBindBaseEvent {
+    readonly type: 'message-sent';
+    /** Recipient DID */
+    readonly recipientDid: string;
+    /** Message identifier */
+    readonly messageId: string;
+    /** Message payload size in bytes */
+    readonly payloadSize: number;
+    /** Envelope version used (v1-v4) */
+    readonly envelopeVersion: string;
+}
+/** Emitted when a message is received */
+export interface MessageReceivedEvent extends XBindBaseEvent {
+    readonly type: 'message-received';
+    /** Sender DID */
+    readonly senderDid: string;
+    /** Decoded message */
+    readonly message: AgentMessage;
+    /** Message identifier */
+    readonly messageId: string;
+    /** Whether signature was verified */
+    readonly verified: boolean;
+}
+/** Emitted when encryption keys are rotated */
+export interface KeyRotatedEvent extends XBindBaseEvent {
+    readonly type: 'key-rotated';
+    /** Key type rotated (ed25519, x25519, mlkem, mldsa) */
+    readonly keyType: 'ed25519' | 'x25519' | 'mlkem' | 'mldsa';
+    /** New public key (base64) */
+    readonly newPublicKey: string;
+    /** Previous public key (base64, if available) */
+    readonly previousPublicKey?: string;
+    /** Reason for rotation */
+    readonly reason: string;
+}
+/** Emitted when an error occurs */
+export interface ErrorEvent extends XBindBaseEvent {
+    readonly type: 'error';
+    /** Error code */
+    readonly code: string;
+    /** Error message */
+    readonly message: string;
+    /** Context where error occurred */
+    readonly context: string;
+    /** Detailed error information */
+    readonly details?: Record<string, unknown>;
+}
+/** Emitted when connection status changes */
+export interface ConnectionStatusEvent extends XBindBaseEvent {
+    readonly type: 'connection-status';
+    /** Current connection status */
+    readonly status: ConnectionStatus;
+    /** Previous connection status */
+    readonly previousStatus?: ConnectionStatus;
+    /** Additional context (error message, reconnect attempt, etc.) */
+    readonly context?: string;
+}
+/** Event listener function signature */
+export type EventListener<T extends XBindBaseEvent = XBindBaseEvent> = (event: T) => void | Promise<void>;
+/** Options for event emission */
+export interface EmitOptions {
+    /** Whether to bubble event to parent emitters */
+    bubble?: boolean;
+    /** Whether to stop propagation after first listener */
+    stopPropagation?: boolean;
+    /** Custom event ID (auto-generated if not provided) */
+    eventId?: string;
+}
+/** Options for event listener registration */
+export interface ListenerOptions {
+    /** Listener priority (higher = called first) */
+    priority?: number;
+    /** Whether listener should only fire once */
+    once?: boolean;
+}
+/** Event emitter error codes */
+export type EventEmitterErrorCode = 'INVALID_EVENT_TYPE' | 'INVALID_LISTENER' | 'LISTENER_ERROR' | 'MAX_LISTENERS_EXCEEDED' | 'DISPOSED';
+/**
+ * Type-safe event emitter for xBind agent events.
+ *
+ * Features:
+ * - Type-safe event names and payloads
+ * - Listener priority support
+ * - Once listeners
+ * - Event bubbling to parent emitters
+ * - Async listener support with error handling
+ * - Memory leak detection
+ *
+ * @example
+ * ```typescript
+ * const emitter = new XBindEventEmitter();
+ *
+ * // Register listener
+ * emitter.on('message-received', (event) => {
+ *   console.log('Received from:', event.senderDid);
+ * });
+ *
+ * // Register one-time listener
+ * emitter.once('connection-status', (event) => {
+ *   console.log('Status:', event.status);
+ * });
+ *
+ * // Emit event
+ * await emitter.emit('message-received', {
+ *   type: 'message-received',
+ *   timestamp: new Date().toISOString(),
+ *   eventId: '123',
+ *   senderDid: 'did:key:z6Mk...',
+ *   message: { payload: 'Hello' },
+ *   messageId: 'msg-1',
+ *   verified: true
+ * });
+ * ```
+ */
+export declare class XBindEventEmitter {
+    private listeners;
+    private parent?;
+    private disposed;
+    private eventCounter;
+    /** Maximum listeners per event type before warning (0 = unlimited) */
+    private maxListeners;
+    /** Whether warnings are enabled */
+    private warningsEnabled;
+    /**
+     * Create a new event emitter.
+     *
+     * @param parent - Optional parent emitter for event bubbling
+     */
+    constructor(parent?: XBindEventEmitter);
+    /**
+     * Register an event listener.
+     *
+     * @param eventType - Event type to listen for
+     * @param listener - Listener function
+     * @param options - Listener options (priority, once)
+     * @returns This emitter for chaining
+     *
+     * @example
+     * ```typescript
+     * emitter.on('error', (event) => {
+     *   console.error('Error:', event.message);
+     * }, { priority: 10 });
+     * ```
+     */
+    on<K extends keyof XBindEventMap>(eventType: K, listener: EventListener<XBindEventMap[K]>, options?: ListenerOptions): this;
+    /**
+     * Register a one-time event listener.
+     * Listener is automatically removed after first invocation.
+     *
+     * @param eventType - Event type to listen for
+     * @param listener - Listener function
+     * @param options - Listener options (priority)
+     * @returns This emitter for chaining
+     *
+     * @example
+     * ```typescript
+     * emitter.once('connection-status', (event) => {
+     *   console.log('First status change:', event.status);
+     * });
+     * ```
+     */
+    once<K extends keyof XBindEventMap>(eventType: K, listener: EventListener<XBindEventMap[K]>, options?: Omit<ListenerOptions, 'once'>): this;
+    /**
+     * Remove an event listener.
+     *
+     * @param eventType - Event type
+     * @param listener - Listener function to remove
+     * @returns This emitter for chaining
+     *
+     * @example
+     * ```typescript
+     * const handler = (event) => console.log(event);
+     * emitter.on('error', handler);
+     * emitter.off('error', handler);
+     * ```
+     */
+    off<K extends keyof XBindEventMap>(eventType: K, listener: EventListener<XBindEventMap[K]>): this;
+    /**
+     * Remove all listeners for an event type, or all listeners if no type specified.
+     *
+     * @param eventType - Optional event type (removes all if not specified)
+     * @returns This emitter for chaining
+     *
+     * @example
+     * ```typescript
+     * emitter.removeAllListeners('error'); // Remove all error listeners
+     * emitter.removeAllListeners(); // Remove all listeners
+     * ```
+     */
+    removeAllListeners<K extends keyof XBindEventMap>(eventType?: K): this;
+    /**
+     * Emit an event to all registered listeners.
+     * Listeners are called in priority order (highest first).
+     * Async listeners are awaited in sequence.
+     *
+     * @param eventType - Event type to emit
+     * @param event - Event payload
+     * @param options - Emission options (bubble, stopPropagation)
+     * @returns Result indicating success or first error encountered
+     *
+     * @example
+     * ```typescript
+     * await emitter.emit('error', {
+     *   type: 'error',
+     *   timestamp: new Date().toISOString(),
+     *   eventId: '123',
+     *   code: 'NETWORK_ERROR',
+     *   message: 'Connection failed',
+     *   context: 'transport'
+     * });
+     * ```
+     */
+    emit<K extends keyof XBindEventMap>(eventType: K, event: Omit<XBindEventMap[K], 'eventId' | 'timestamp'>, options?: EmitOptions): Promise<Result<void, EventEmitterErrorCode>>;
+    /**
+     * Check if there are any listeners for an event type.
+     *
+     * @param eventType - Event type to check
+     * @returns True if there are listeners
+     *
+     * @example
+     * ```typescript
+     * if (emitter.hasListeners('error')) {
+     *   await emitter.emit('error', errorEvent);
+     * }
+     * ```
+     */
+    hasListeners<K extends keyof XBindEventMap>(eventType: K): boolean;
+    /**
+     * Get the number of listeners for an event type.
+     *
+     * @param eventType - Event type
+     * @returns Number of listeners
+     *
+     * @example
+     * ```typescript
+     * const count = emitter.listenerCount('message-received');
+     * console.log(`${count} listeners registered`);
+     * ```
+     */
+    listenerCount<K extends keyof XBindEventMap>(eventType: K): number;
+    /**
+     * Get all registered event types.
+     *
+     * @returns Array of event types with active listeners
+     *
+     * @example
+     * ```typescript
+     * const events = emitter.eventNames();
+     * console.log('Active events:', events);
+     * ```
+     */
+    eventNames(): Array<keyof XBindEventMap>;
+    /**
+     * Set the maximum number of listeners per event before warning.
+     * Use 0 for unlimited listeners.
+     *
+     * @param n - Maximum listeners (0 = unlimited)
+     * @returns This emitter for chaining
+     *
+     * @example
+     * ```typescript
+     * emitter.setMaxListeners(20); // Allow up to 20 listeners
+     * emitter.setMaxListeners(0);  // Unlimited
+     * ```
+     */
+    setMaxListeners(n: number): this;
+    /**
+     * Get the maximum number of listeners per event.
+     *
+     * @returns Maximum listeners (0 = unlimited)
+     */
+    getMaxListeners(): number;
+    /**
+     * Enable or disable memory leak warnings.
+     *
+     * @param enabled - Whether warnings are enabled
+     * @returns This emitter for chaining
+     */
+    setWarningsEnabled(enabled: boolean): this;
+    /**
+     * Set the parent emitter for event bubbling.
+     *
+     * @param parent - Parent emitter (undefined to remove parent)
+     * @returns This emitter for chaining
+     *
+     * @example
+     * ```typescript
+     * const parent = new XBindEventEmitter();
+     * const child = new XBindEventEmitter();
+     * child.setParent(parent);
+     *
+     * parent.on('error', (event) => console.log('Parent received:', event));
+     * await child.emit('error', errorEvent, { bubble: true });
+     * ```
+     */
+    setParent(parent: XBindEventEmitter | undefined): this;
+    /**
+     * Get the parent emitter.
+     *
+     * @returns Parent emitter or undefined
+     */
+    getParent(): XBindEventEmitter | undefined;
+    /**
+     * Wait for a specific event to be emitted.
+     * Returns a promise that resolves with the event payload.
+     *
+     * @param eventType - Event type to wait for
+     * @param timeout - Optional timeout in milliseconds
+     * @returns Promise resolving to event or rejecting on timeout
+     *
+     * @example
+     * ```typescript
+     * const event = await emitter.waitFor('connection-status', 5000);
+     * console.log('Status changed to:', event.status);
+     * ```
+     */
+    waitFor<K extends keyof XBindEventMap>(eventType: K, timeout?: number): Promise<XBindEventMap[K]>;
+    /**
+     * Dispose the event emitter and remove all listeners.
+     * After disposal, no events can be emitted and listeners cannot be registered.
+     *
+     * @example
+     * ```typescript
+     * emitter.dispose();
+     * ```
+     */
+    dispose(): void;
+    /**
+     * Check if the emitter has been disposed.
+     *
+     * @returns True if disposed
+     */
+    isDisposed(): boolean;
+    private checkDisposed;
+    private generateEventId;
+}
+/**
+ * Create a scoped event emitter that only emits specific event types.
+ * Useful for isolating event channels.
+ *
+ * @param parent - Parent emitter
+ * @param allowedEvents - Array of allowed event types
+ * @returns Scoped event emitter
+ *
+ * @example
+ * ```typescript
+ * const parent = new XBindEventEmitter();
+ * const errorOnly = createScopedEmitter(parent, ['error']);
+ *
+ * errorOnly.emit('error', errorEvent); // OK
+ * errorOnly.emit('message-sent', event); // TypeScript error
+ * ```
+ */
+export declare function createScopedEmitter<K extends keyof XBindEventMap>(parent: XBindEventEmitter, allowedEvents: readonly K[]): {
+    on: <T extends K>(type: T, listener: EventListener<XBindEventMap[T]>, options?: ListenerOptions) => XBindEventEmitter;
+    once: <T extends K>(type: T, listener: EventListener<XBindEventMap[T]>, options?: Omit<ListenerOptions, 'once'>) => XBindEventEmitter;
+    off: <T extends K>(type: T, listener: EventListener<XBindEventMap[T]>) => XBindEventEmitter;
+    emit: <T extends K>(type: T, event: Omit<XBindEventMap[T], 'eventId' | 'timestamp'>, options?: EmitOptions) => Promise<Result<void, EventEmitterErrorCode>>;
+    hasListeners: <T extends K>(type: T) => boolean;
+    listenerCount: <T extends K>(type: T) => number;
+    dispose: () => void;
+};

package/dist-standalone/event-emitter.js

@@ -0,0 +1 @@
+import{ok,err}from"./_deps/shared/index.js";export class XBindEventEmitter{listeners=new Map;parent;disposed=!1;eventCounter=0;maxListeners=10;warningsEnabled=!0;constructor(e){this.parent=e}on(e,t,s={}){if(this.checkDisposed(),"function"!=typeof t)throw new Error("Listener must be a function");const r=this.listeners.get(e)??[],n={listener:t,once:s.once??!1,priority:s.priority??0};return r.push(n),r.sort((e,t)=>t.priority-e.priority),this.listeners.set(e,r),this.warningsEnabled&&this.maxListeners>0&&r.length>this.maxListeners&&console.warn(`[xBind EventEmitter] Possible memory leak detected: ${r.length} listeners for event '${e}'. Use emitter.setMaxListeners() to increase limit.`),this}once(e,t,s={}){return this.on(e,t,{...s,once:!0})}off(e,t){this.checkDisposed();const s=this.listeners.get(e);if(!s)return this;const r=s.filter(e=>e.listener!==t);return 0===r.length?this.listeners.delete(e):this.listeners.set(e,r),this}removeAllListeners(e){return this.checkDisposed(),e?this.listeners.delete(e):this.listeners.clear(),this}async emit(e,t,s={}){this.checkDisposed();const r={...t,eventId:s.eventId??this.generateEventId(),timestamp:(new Date).toISOString()},n=this.listeners.get(e);if(n&&n.length>0){const t=[...n];for(const n of t)try{if(await n.listener(r),n.once&&this.off(e,n.listener),s.stopPropagation)return ok(void 0)}catch(t){return console.error(`[xBind EventEmitter] Error in listener for '${e}':`,t),err("LISTENER_ERROR")}}return!1!==s.bubble&&this.parent?this.parent.emit(e,t,{...s,bubble:!0}):ok(void 0)}hasListeners(e){const t=this.listeners.get(e);return void 0!==t&&t.length>0}listenerCount(e){const t=this.listeners.get(e);return t?.length??0}eventNames(){return Array.from(this.listeners.keys())}setMaxListeners(e){if(e<0||!Number.isInteger(e))throw new Error("Max listeners must be a non-negative integer");return this.maxListeners=e,this}getMaxListeners(){return this.maxListeners}setWarningsEnabled(e){return this.warningsEnabled=e,this}setParent(e){return this.parent=e,this}getParent(){return this.parent}waitFor(e,t){return new Promise((s,r)=>{let n;const i=e=>{n&&clearTimeout(n),s(e)};this.once(e,i),void 0!==t&&t>0&&(n=setTimeout(()=>{this.off(e,i),r(new Error(`Timeout waiting for event '${e}' after ${t}ms`))},t))})}dispose(){this.disposed=!0,this.listeners.clear(),this.parent=void 0}isDisposed(){return this.disposed}checkDisposed(){if(this.disposed)throw new Error("EventEmitter has been disposed")}generateEventId(){return`evt-${Date.now()}-${++this.eventCounter}`}}export function createScopedEmitter(e,t){const s=new XBindEventEmitter(e),r=new Set(t);return{on:(e,t,n)=>{if(!r.has(e))throw new Error(`Event type '${String(e)}' not allowed in scoped emitter`);return s.on(e,t,n)},once:(e,t,n)=>{if(!r.has(e))throw new Error(`Event type '${String(e)}' not allowed in scoped emitter`);return s.once(e,t,n)},off:(e,t)=>s.off(e,t),emit:(e,t,n)=>r.has(e)?s.emit(e,t,n):Promise.resolve(err("INVALID_EVENT_TYPE")),hasListeners:e=>s.hasListeners(e),listenerCount:e=>s.listenerCount(e),dispose:()=>s.dispose()}}

package/dist-standalone/gateway-state.js

@@ -1,51 +1 @@
-/**
- * Gateway connection state manager.
- *
- * Online-only model: State evaporates immediately on disconnect.
- * No 12-hour windows, no persistent state.
- *
- * Note: WebSocket type is runtime-dependent (browser WebSocket or 'ws' package).
- */
-export class GatewayConnectionState {
-    connections = new Map(); // did → socket
-    /**
-     * Register agent connection.
-     *
-     * @param did - DID of the connecting agent
-     * @param socket - WebSocket connection (browser or Node.js 'ws' package)
-     */
-    connect(did, socket) {
-        this.connections.set(did, socket);
-        // Handle close event (works for both browser and Node.js ws)
-        if (typeof socket.on === 'function') {
-            // Node.js 'ws' package style
-            socket.on('close', () => {
-                this.connections.delete(did); // Immediate evaporation
-            });
-        }
-        else if (socket.addEventListener) {
-            // Browser WebSocket style
-            socket.addEventListener('close', () => {
-                this.connections.delete(did);
-            });
-        }
-    }
-    /**
-     * Check if agent is currently online.
-     */
-    isOnline(did) {
-        return this.connections.has(did);
-    }
-    /**
-     * Get WebSocket for online agent (or null if offline).
-     */
-    getSocket(did) {
-        return this.connections.get(did) ?? null;
-    }
-    /**
-     * Get all online DIDs.
-     */
-    getOnlineDids() {
-        return Array.from(this.connections.keys());
-    }
-}
+export class GatewayConnectionState{connections=new Map;connect(n,e){this.connections.set(n,e),"function"==typeof e.on?e.on("close",()=>{this.connections.delete(n)}):e.addEventListener&&e.addEventListener("close",()=>{this.connections.delete(n)})}isOnline(n){return this.connections.has(n)}getSocket(n){return this.connections.get(n)??null}getOnlineDids(){return Array.from(this.connections.keys())}}

package/dist-standalone/gateway-transport.js

@@ -1,116 +1 @@
-/**
- * Gateway transport adapter for delivering envelopes to Xail inbox users.
- *
- * Sends envelopes via POST /gateway/deliver on the hosted gateway API.
- * For agent-to-agent (M2M), use HttpsTransportAdapter with direct URLs.
- * Optionally polls for incoming messages.
- */
-import { ok, err } from"./_deps/shared/index.js";
-/**
- * Transport adapter for the Xail Gateway.
- *
- * Sends envelopes via POST /gateway/deliver with API key auth.
- * Optionally polls GET /gateway/messages/:did for incoming messages.
- */
-export class GatewayTransport {
-    apiKey;
-    gateway;
-    timeoutMs;
-    fetchFn;
-    pollIntervalMs;
-    handlers = [];
-    pollTimer = null;
-    senderDid = null;
-    constructor(opts) {
-        this.apiKey = opts.apiKey;
-        this.gateway = opts.gateway.replace(/\/$/, '');
-        this.timeoutMs = opts.timeoutMs ?? 15_000;
-        this.fetchFn = opts.fetch ?? globalThis.fetch.bind(globalThis);
-        this.pollIntervalMs = opts.pollIntervalMs ?? 0;
-    }
-    /**
-     * Send a signed envelope to a recipient via the gateway.
-     * @param envelope - The signed transport envelope.
-     * @param _recipientDid - Recipient DID (already in envelope.recipient).
-     * @returns Success or transport error.
-     */
-    async send(envelope, _recipientDid) {
-        const url = `${this.gateway}/gateway/deliver`;
-        try {
-            const controller = new AbortController();
-            const timer = setTimeout(() => controller.abort(), this.timeoutMs);
-            const response = await this.fetchFn(url, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'Authorization': `Bearer ${this.apiKey}`,
-                },
-                body: JSON.stringify(envelope),
-                signal: controller.signal,
-            });
-            clearTimeout(timer);
-            if (!response.ok) {
-                return err(response.status === 404
-                    ? 'RECIPIENT_UNREACHABLE'
-                    : 'SEND_FAILED');
-            }
-            return ok(undefined);
-        }
-        catch (e) {
-            if (e instanceof DOMException && e.name === 'AbortError') {
-                return err('TIMEOUT');
-            }
-            return err('NETWORK_ERROR');
-        }
-    }
-    /** Register a handler for incoming envelopes. */
-    onReceive(handler) {
-        this.handlers.push(handler);
-    }
-    /**
-     * Start polling for incoming messages.
-     * Must be called after Agent.create() sets the sender DID.
-     * @param did - The agent's own DID for polling.
-     */
-    startPolling(did) {
-        this.senderDid = did;
-        if (this.pollIntervalMs > 0 && !this.pollTimer) {
-            this.pollTimer = setInterval(() => void this.poll(), this.pollIntervalMs);
-        }
-    }
-    /** Shut down the transport (stop polling, clear handlers). */
-    dispose() {
-        if (this.pollTimer) {
-            clearInterval(this.pollTimer);
-            this.pollTimer = null;
-        }
-        this.handlers = [];
-    }
-    /** Poll for incoming messages and dispatch to handlers. */
-    async poll() {
-        if (!this.senderDid)
-            return;
-        try {
-            const url = `${this.gateway}/gateway/messages/${encodeURIComponent(this.senderDid)}`;
-            const res = await this.fetchFn(url, {
-                headers: { Authorization: `Bearer ${this.apiKey}` },
-            });
-            if (!res.ok)
-                return;
-            const data = (await res.json());
-            for (const msg of data.messages) {
-                for (const handler of this.handlers) {
-                    handler(msg.envelope);
-                }
-                // Ack delivery
-                await this.fetchFn(`${this.gateway}/gateway/ack/${msg.id}`, {
-                    method: 'POST',
-                    headers: { Authorization: `Bearer ${this.apiKey}` },
-                });
-            }
-        }
-        catch {
-            // Silent failure — polling errors are non-fatal
-        }
-    }
-}
+import{ok,err}from"./_deps/shared/index.js";export class GatewayTransport{apiKey;gateway;timeoutMs;fetchFn;pollIntervalMs;handlers=[];pollTimer=null;senderDid=null;constructor(e){this.apiKey=e.apiKey,this.gateway=e.gateway.replace(/\/$/,""),this.timeoutMs=e.timeoutMs??15e3,this.fetchFn=e.fetch??globalThis.fetch.bind(globalThis),this.pollIntervalMs=e.pollIntervalMs??0}async send(e,t){const s=`${this.gateway}/gateway/deliver`;try{const t=new AbortController,i=setTimeout(()=>t.abort(),this.timeoutMs),a=await this.fetchFn(s,{method:"POST",headers:{"Content-Type":"application/json",Authorization:`Bearer ${this.apiKey}`},body:JSON.stringify(e),signal:t.signal});return clearTimeout(i),a.ok?ok(void 0):err(404===a.status?"RECIPIENT_UNREACHABLE":"SEND_FAILED")}catch(e){return e instanceof DOMException&&"AbortError"===e.name?err("TIMEOUT"):err("NETWORK_ERROR")}}onReceive(e){this.handlers.push(e)}startPolling(e){this.senderDid=e,this.pollIntervalMs>0&&!this.pollTimer&&(this.pollTimer=setInterval(()=>{this.poll()},this.pollIntervalMs))}dispose(){this.pollTimer&&(clearInterval(this.pollTimer),this.pollTimer=null),this.handlers=[]}async poll(){if(this.senderDid)try{const e=`${this.gateway}/gateway/messages/${encodeURIComponent(this.senderDid)}`,t=await this.fetchFn(e,{headers:{Authorization:`Bearer ${this.apiKey}`}});if(!t.ok)return;const s=await t.json();for(const e of s.messages){for(const t of this.handlers)t(e.envelope);await this.fetchFn(`${this.gateway}/gateway/ack/${e.id}`,{method:"POST",headers:{Authorization:`Bearer ${this.apiKey}`}})}}catch{}}}