@multi-agent-protocol/sdk 0.0.2

package/dist/index.d.cts

@@ -0,0 +1,2288 @@
+import { R as RequestId, M as MAPError, a as MAPErrorData, E as ErrorCategory, F as FederationBufferConfig, b as FederationEnvelope, c as Message, S as Stream, B as BaseConnectionOptions, P as ParticipantCapabilities, d as FederationRoutingConfig, e as EventType, C as ConnectResponseResult, f as SessionId, g as FederationConnectResponseResult, h as FederationRouteResponseResult, i as ConnectionState, j as ParticipantId, k as ParticipantType, A as AgentId, l as ScopeId, m as Agent, n as Scope, o as Address, p as SubscriptionFilter, q as Event, r as AgentsGetResponseResult, s as AgentsListResponseResult, t as AgentsRegisterResponseResult, u as AgentsSpawnResponseResult, v as AgentsUnregisterResponseResult, w as AgentsUpdateResponseResult, x as ProtocolVersion, y as SessionInfo, D as DisconnectResponseResult, z as ScopesCreateResponseResult, G as ScopesJoinResponseResult, H as ScopesLeaveResponseResult, I as ScopesListResponseResult, J as MessageId, K as SendResponseResult, L as SubscriptionId, N as SubscribeResponseResult, U as UnsubscribeResponseResult } from './index-C7XPWnxS.cjs';
+export { O as AGENT_ERROR_CODES, Q as AUTH_ERROR_CODES, T as AUTH_METHODS, V as AcceptanceContext, W as AgentAcceptanceRule, X as AgentConnection, Y as AgentConnectionOptions, Z as AgentIncludeOptions, _ as AgentLifecycle, $ as AgentMessagingRule, a0 as AgentPermissionConfig, a1 as AgentPermissions, a2 as AgentReconnectionEventHandler, a3 as AgentReconnectionEventType, a4 as AgentReconnectionOptions, a5 as AgentRelationship, a6 as AgentRelationshipType, a7 as AgentState, a8 as AgentVisibility, a9 as AgentVisibilityRule, aa as AgentsGetRequest, ab as AgentsGetRequestParams, ac as AgentsListFilter, ad as AgentsListRequest, ae as AgentsListRequestParams, af as AgentsRegisterRequest, ag as AgentsRegisterRequestParams, ah as AgentsResumeRequest, ai as AgentsResumeRequestParams, aj as AgentsResumeResponseResult, ak as AgentsSpawnRequest, al as AgentsSpawnRequestParams, am as AgentsStopRequest, an as AgentsStopRequestParams, ao as AgentsStopResponseResult, ap as AgentsSuspendRequest, aq as AgentsSuspendRequestParams, ar as AgentsSuspendResponseResult, as as AgentsUnregisterRequest, at as AgentsUnregisterRequestParams, au as AgentsUpdateRequest, av as AgentsUpdateRequestParams, aw as AnyMessage, ax as AuthMethod, ay as AuthParams, az as AuthRefreshRequest, aA as AuthRefreshRequestParams, aB as AuthRefreshResponseResult, aC as BaseConnection, aD as BroadcastAddress, aE as CAPABILITY_REQUIREMENTS, aF as CORE_METHODS, aG as ClientAcceptanceRule, aH as ClientConnection, aI as ClientConnectionOptions, aJ as ConnectRequest, aK as ConnectRequestParams, aL as CorrelationId, aM as DEFAULT_AGENT_PERMISSION_CONFIG, aN as DeliverySemantics, aO as DirectAddress, aP as DisconnectPolicy, aQ as DisconnectRequest, aR as DisconnectRequestParams, aS as ERROR_CODES, aT as EVENT_TYPES, aU as EXTENSION_METHODS, aV as EventInput, aW as EventNotification, aX as EventNotificationParams, aY as FEDERATION_ERROR_CODES, aZ as FEDERATION_METHODS, a_ as FederatedAddress, a$ as FederationAuth, b0 as FederationConnectRequest, b1 as FederationConnectRequestParams, b2 as FederationMetadata, b3 as FederationReplayConfig, b4 as FederationRouteRequest, b5 as FederationRouteRequestParams, b6 as GatewayReconnectionEvent, b7 as GatewayReconnectionEventHandler, b8 as GatewayReconnectionEventType, b9 as GatewayReconnectionOptions, ba as GraphEdge, bb as HierarchicalAddress, bc as InjectDelivery, bd as InjectDeliveryResult, be as InjectRequest, bf as InjectRequestParams, bg as InjectResponseResult, bh as JSONRPC_VERSION, bi as JoinPolicy, bj as LIFECYCLE_METHODS, bk as MAPNotification, bl as MAPNotificationBase, bm as MAPRequest, bn as MAPRequestBase, bo as MAPResponse, bp as MAPResponseError, bq as MAPResponseSuccess, br as MAP_METHODS, bs as MessageDeliveredEventData, bt as MessageFailedEventData, bu as MessageHandler, bv as MessageMeta, bw as MessageNotification, bx as MessageNotificationParams, by as MessagePriority, bz as MessageRelationship, bA as MessageSentEventData, bB as MessageVisibility, bC as Meta, bD as MultiAddress, bE as NOTIFICATION_METHODS, bF as NotificationHandler, bG as OBSERVATION_METHODS, bH as OverflowHandler, bI as OverflowInfo, bJ as PERMISSION_METHODS, bK as PROTOCOL_ERROR_CODES, bL as PROTOCOL_VERSION, bM as Participant, bN as ParticipantAddress, bO as PermissionAction, bP as PermissionContext, bQ as PermissionParticipant, bR as PermissionResult, bS as PermissionSystemConfig, bT as PermissionsAgentUpdatedEventData, bU as PermissionsClientUpdatedEventData, bV as PermissionsUpdateRequest, bW as PermissionsUpdateRequestParams, bX as PermissionsUpdateResponseResult, bY as RESOURCE_ERROR_CODES, bZ as ROUTING_ERROR_CODES, b_ as ReconnectionEventHandler, b$ as ReconnectionEventType, c0 as ReconnectionOptions, c1 as ReplayRequest, c2 as ReplayRequestParams, c3 as ReplayResponseResult, c4 as ReplayedEvent, c5 as RequestHandler, c6 as RoleAddress, c7 as SCOPE_METHODS, c8 as SESSION_METHODS, c9 as STATE_METHODS, ca as STEERING_METHODS, cb as STRUCTURE_METHODS, cc as ScopeAddress, cd as ScopeMessagingRule, ce as ScopeVisibility, cf as ScopeVisibilityRule, cg as ScopesCreateRequest, ch as ScopesCreateRequestParams, ci as ScopesDeleteRequest, cj as ScopesDeleteRequestParams, ck as ScopesDeleteResponseResult, cl as ScopesGetRequest, cm as ScopesGetRequestParams, cn as ScopesGetResponseResult, co as ScopesJoinRequest, cp as ScopesJoinRequestParams, cq as ScopesLeaveRequest, cr as ScopesLeaveRequestParams, cs as ScopesListRequest, ct as ScopesListRequestParams, cu as ScopesMembersRequest, cv as ScopesMembersRequestParams, cw as ScopesMembersResponseResult, cx as SendPolicy, cy as SendRequest, cz as SendRequestParams, cA as SessionCloseRequest, cB as SessionCloseRequestParams, cC as SessionCloseResponseResult, cD as SessionListRequest, cE as SessionListRequestParams, cF as SessionListResponseResult, cG as SessionLoadRequest, cH as SessionLoadRequestParams, cI as SessionLoadResponseResult, cJ as StateChangeHandler, cK as StreamingCapabilities, cL as StructureGraphRequest, cM as StructureGraphRequestParams, cN as StructureGraphResponseResult, cO as StructureVisibilityRule, cP as SubscribeRequest, cQ as SubscribeRequestParams, cR as Subscription, cS as SubscriptionAckNotification, cT as SubscriptionAckParams, cU as SubscriptionOptions, cV as SubscriptionState, cW as SystemAcceptanceRule, cX as SystemAddress, cY as Timestamp, cZ as TransportType, c_ as UnsubscribeRequest, c$ as UnsubscribeRequestParams, d0 as canAgentAcceptMessage, d1 as canAgentMessageAgent, d2 as canAgentSeeAgent, d3 as canControlAgent, d4 as canJoinScope, d5 as canMessageAgent, d6 as canPerformAction, d7 as canPerformMethod, d8 as canSeeAgent, d9 as canSeeScope, da as canSendToScope, db as createEvent, dc as createStreamPair, dd as createSubscription, de as deepMergePermissions, df as filterVisibleAgents, dg as filterVisibleEvents, dh as filterVisibleScopes, di as hasCapability, dj as isAgentExposed, dk as isBroadcastAddress, dl as isDirectAddress, dm as isEventTypeExposed, dn as isFederatedAddress, dp as isHierarchicalAddress, dq as isOrphanedAgent, dr as isScopeAddress, ds as isScopeExposed, dt as isSuccessResponse, du as mapVisibilityToRule, dv as ndJsonStream, dw as resolveAgentPermissions, dx as websocketStream } from './index-C7XPWnxS.cjs';
+import { z } from 'zod';
+export { monotonicFactory, ulid } from 'ulid';
+
+/**
+ * JSON-RPC 2.0 utilities for MAP protocol
+ */
+
+/**
+ * Generic JSON-RPC request structure
+ */
+interface JsonRpcRequest<TParams = unknown> {
+    jsonrpc: '2.0';
+    id: RequestId;
+    method: string;
+    params?: TParams;
+}
+/**
+ * Generic JSON-RPC notification structure (no id)
+ */
+interface JsonRpcNotification<TParams = unknown> {
+    jsonrpc: '2.0';
+    method: string;
+    params?: TParams;
+}
+/**
+ * Generic JSON-RPC success response
+ */
+interface JsonRpcSuccessResponse<TResult = unknown> {
+    jsonrpc: '2.0';
+    id: RequestId;
+    result: TResult;
+}
+/**
+ * Generic JSON-RPC error response
+ */
+interface JsonRpcErrorResponse {
+    jsonrpc: '2.0';
+    id: RequestId;
+    error: MAPError;
+}
+/**
+ * Any JSON-RPC response
+ */
+type JsonRpcResponse<TResult = unknown> = JsonRpcSuccessResponse<TResult> | JsonRpcErrorResponse;
+/**
+ * Check if a message is a request (has id and method)
+ */
+declare function isRequest(message: unknown): message is JsonRpcRequest;
+/**
+ * Check if a message is a notification (has method but no id)
+ */
+declare function isNotification(message: unknown): message is JsonRpcNotification;
+/**
+ * Check if a message is a response (has id but no method)
+ */
+declare function isResponse(message: unknown): message is JsonRpcResponse;
+/**
+ * Check if a response is an error response
+ */
+declare function isErrorResponse(response: JsonRpcResponse): response is JsonRpcErrorResponse;
+/**
+ * Create a JSON-RPC request
+ */
+declare function createRequest<TParams>(id: RequestId, method: string, params?: TParams): JsonRpcRequest<TParams>;
+/**
+ * Create a JSON-RPC notification
+ */
+declare function createNotification<TParams>(method: string, params?: TParams): JsonRpcNotification<TParams>;
+/**
+ * Create a JSON-RPC success response
+ */
+declare function createSuccessResponse<TResult>(id: RequestId, result: TResult): JsonRpcSuccessResponse<TResult>;
+/**
+ * Create a JSON-RPC error response
+ */
+declare function createErrorResponse(id: RequestId, error: MAPError): JsonRpcErrorResponse;
+
+/**
+ * Error classes for MAP protocol
+ */
+
+/**
+ * Error thrown when a MAP request fails.
+ *
+ * Extends Error with JSON-RPC error properties and provides
+ * factory methods for common error types.
+ */
+declare class MAPRequestError extends Error {
+    readonly code: number;
+    readonly data?: MAPErrorData;
+    constructor(code: number, message: string, data?: MAPErrorData);
+    /**
+     * Convert to MAP error object
+     */
+    toError(): MAPError;
+    /**
+     * Convert to JSON-RPC error response
+     */
+    toResponse(id: RequestId): JsonRpcErrorResponse;
+    static parseError(details?: string): MAPRequestError;
+    static invalidRequest(details?: string): MAPRequestError;
+    static methodNotFound(method: string): MAPRequestError;
+    static invalidParams(details?: unknown): MAPRequestError;
+    static internalError(details?: string): MAPRequestError;
+    static authRequired(): MAPRequestError;
+    static authFailed(details?: string): MAPRequestError;
+    static tokenExpired(): MAPRequestError;
+    static permissionDenied(required?: string): MAPRequestError;
+    static addressNotFound(address: string): MAPRequestError;
+    static agentNotFound(agentId: string): MAPRequestError;
+    static scopeNotFound(scopeId: string): MAPRequestError;
+    static deliveryFailed(details?: string): MAPRequestError;
+    static addressAmbiguous(address: string): MAPRequestError;
+    static agentExists(agentId: string): MAPRequestError;
+    static stateInvalid(currentState: string, requestedAction: string): MAPRequestError;
+    static agentNotResponding(agentId: string): MAPRequestError;
+    static agentTerminated(agentId: string): MAPRequestError;
+    static spawnFailed(details?: string): MAPRequestError;
+    static resourceExhausted(resource?: string): MAPRequestError;
+    static rateLimited(retryAfterMs?: number): MAPRequestError;
+    static quotaExceeded(quota?: string): MAPRequestError;
+    static federationUnavailable(systemId?: string): MAPRequestError;
+    static federationSystemNotFound(systemId: string): MAPRequestError;
+    static federationAuthFailed(systemId: string): MAPRequestError;
+    static federationRouteRejected(systemId: string, reason?: string): MAPRequestError;
+    /**
+     * Create from a MAP error object
+     */
+    static fromError(error: MAPError): MAPRequestError;
+    /**
+     * Check if this error is retryable
+     */
+    get retryable(): boolean;
+    /**
+     * Get retry delay in milliseconds, if specified
+     */
+    get retryAfterMs(): number | undefined;
+    /**
+     * Get error category
+     */
+    get category(): ErrorCategory | undefined;
+}
+/**
+ * Error thrown when a connection is closed unexpectedly
+ */
+declare class MAPConnectionError extends Error {
+    constructor(message: string);
+    static closed(): MAPConnectionError;
+    static timeout(): MAPConnectionError;
+}
+/**
+ * Error thrown when an operation times out
+ */
+declare class MAPTimeoutError extends Error {
+    readonly timeoutMs: number;
+    constructor(operation: string, timeoutMs: number);
+}
+
+/**
+ * Federation Outage Buffer
+ *
+ * Buffers outbound messages during federation outages for later delivery
+ * when the peer reconnects.
+ */
+
+/**
+ * Buffer statistics for a peer.
+ */
+interface PeerBufferStats {
+    /** Number of messages currently buffered */
+    count: number;
+    /** Age of oldest message in milliseconds */
+    oldestAge: number;
+    /** Total messages ever enqueued */
+    totalEnqueued: number;
+    /** Total messages dropped due to overflow/expiry */
+    totalDropped: number;
+    /** Current buffer size in bytes */
+    totalBytes: number;
+}
+/**
+ * Buffer for storing outbound messages during federation outages.
+ *
+ * Messages are stored per-peer and drained on reconnection.
+ * Supports configurable size limits, retention, and overflow strategies.
+ *
+ * @example
+ * ```typescript
+ * const buffer = new FederationOutageBuffer({
+ *   maxMessages: 500,
+ *   retentionMs: 30000,
+ *   overflowStrategy: 'drop-oldest',
+ * });
+ *
+ * // Buffer messages during outage
+ * buffer.enqueue('peer-1', envelope);
+ *
+ * // On reconnect, drain and send
+ * const messages = buffer.drain('peer-1');
+ * for (const msg of messages) {
+ *   await send(msg);
+ * }
+ * ```
+ */
+declare class FederationOutageBuffer {
+    #private;
+    constructor(config?: FederationBufferConfig);
+    /**
+     * Whether buffering is enabled.
+     */
+    get enabled(): boolean;
+    /**
+     * Get the configuration.
+     */
+    get config(): Readonly<Required<FederationBufferConfig>>;
+    /**
+     * Enqueue a message for a peer.
+     *
+     * @param peerId - Target peer system ID
+     * @param envelope - Message envelope to buffer
+     * @returns true if message was buffered, false if rejected
+     */
+    enqueue(peerId: string, envelope: FederationEnvelope<Message>): boolean;
+    /**
+     * Drain all buffered messages for a peer.
+     *
+     * Returns messages in FIFO order and clears the buffer.
+     *
+     * @param peerId - Target peer system ID
+     * @returns Array of buffered envelopes
+     */
+    drain(peerId: string): FederationEnvelope<Message>[];
+    /**
+     * Peek at buffered messages without removing them.
+     *
+     * @param peerId - Target peer system ID
+     * @returns Array of buffered envelopes (still in buffer)
+     */
+    peek(peerId: string): FederationEnvelope<Message>[];
+    /**
+     * Get statistics for all peer buffers.
+     *
+     * @returns Map of peer ID to buffer stats
+     */
+    stats(): Map<string, PeerBufferStats>;
+    /**
+     * Get count for a specific peer.
+     *
+     * @param peerId - Target peer system ID
+     * @returns Number of buffered messages
+     */
+    count(peerId: string): number;
+    /**
+     * Check if buffer has messages for a peer.
+     *
+     * @param peerId - Target peer system ID
+     * @returns true if there are buffered messages
+     */
+    has(peerId: string): boolean;
+    /**
+     * Clear buffer for a specific peer.
+     *
+     * @param peerId - Target peer system ID
+     */
+    clear(peerId: string): void;
+    /**
+     * Clear all buffers.
+     */
+    clearAll(): void;
+    /**
+     * Get list of peers with buffered messages.
+     *
+     * @returns Array of peer IDs
+     */
+    peers(): string[];
+}
+
+/**
+ * Gateway connection for MAP protocol federation
+ *
+ * Used by gateways to connect two MAP systems together,
+ * routing messages between them.
+ */
+
+/**
+ * Options for automatic gateway reconnection
+ */
+interface GatewayReconnectionOptions {
+    /** Enable automatic reconnection (default: false) */
+    enabled: boolean;
+    /** Maximum number of retry attempts (default: 10) */
+    maxRetries?: number;
+    /** Initial delay in milliseconds (default: 1000) */
+    baseDelayMs?: number;
+    /** Maximum delay in milliseconds (default: 30000) */
+    maxDelayMs?: number;
+    /** Add jitter to delays (default: true) */
+    jitter?: boolean;
+}
+/**
+ * Options for event replay on gateway reconnection
+ */
+interface GatewayReplayOptions {
+    /** Enable replay on reconnection (default: false) */
+    enabled: boolean;
+    /** Event types to replay (default: all) */
+    eventTypes?: EventType[];
+    /** Maximum events to replay per peer (default: 1000) */
+    maxEvents?: number;
+    /** Maximum age of events to replay in ms (default: 1 hour) */
+    maxAgeMs?: number;
+}
+/**
+ * Reconnection event types for gateway
+ */
+type GatewayReconnectionEventType = 'disconnected' | 'reconnecting' | 'reconnected' | 'reconnectFailed' | 'bufferOverflow' | 'bufferDrained' | 'replayStarted' | 'replayCompleted';
+/**
+ * Handler for gateway reconnection events
+ */
+type GatewayReconnectionEventHandler = (event: {
+    type: GatewayReconnectionEventType;
+    attempt?: number;
+    delay?: number;
+    error?: Error;
+    peerId?: string;
+    messagesBuffered?: number;
+    messagesDrained?: number;
+    eventsReplayed?: number;
+}) => void;
+/**
+ * Options for gateway connection
+ */
+interface GatewayConnectionOptions extends BaseConnectionOptions {
+    /** Gateway name */
+    name?: string;
+    /** Gateway capabilities */
+    capabilities?: ParticipantCapabilities;
+    /** Federation routing configuration */
+    routing?: FederationRoutingConfig;
+    /** Factory to create new stream for reconnection */
+    createStream?: () => Promise<Stream>;
+    /** Reconnection options */
+    reconnection?: GatewayReconnectionOptions;
+    /** Outage buffer configuration */
+    buffer?: FederationBufferConfig;
+    /** Replay options for reconnection */
+    replay?: GatewayReplayOptions;
+}
+/**
+ * Gateway connection for MAP federation.
+ *
+ * Provides methods for:
+ * - Connecting to peer MAP systems
+ * - Routing messages between systems
+ * - Automatic reconnection with message buffering
+ */
+declare class GatewayConnection {
+    #private;
+    constructor(stream: Stream, options?: GatewayConnectionOptions);
+    /**
+     * Connect to the local MAP system
+     */
+    connect(options?: {
+        auth?: {
+            method: 'bearer' | 'api-key' | 'mtls' | 'none';
+            token?: string;
+        };
+    }): Promise<ConnectResponseResult>;
+    /**
+     * Disconnect from the local MAP system
+     */
+    disconnect(reason?: string): Promise<void>;
+    /**
+     * Whether the gateway is connected to the local system
+     */
+    get isConnected(): boolean;
+    /**
+     * Current session ID
+     */
+    get sessionId(): SessionId | null;
+    /**
+     * Server capabilities
+     */
+    get serverCapabilities(): ParticipantCapabilities | null;
+    /**
+     * List of connected remote systems
+     */
+    get connectedSystems(): Map<string, {
+        name?: string;
+        version?: string;
+    }>;
+    /**
+     * AbortSignal that triggers when the connection closes
+     */
+    get signal(): AbortSignal;
+    /**
+     * Promise that resolves when the connection closes
+     */
+    get closed(): Promise<void>;
+    /**
+     * Connect to a remote MAP system
+     */
+    connectToSystem(systemId: string, endpoint: string, auth?: {
+        method: 'bearer' | 'api-key' | 'mtls';
+        credentials?: string;
+    }): Promise<FederationConnectResponseResult>;
+    /**
+     * Route a message to a remote system.
+     *
+     * If routing config is provided, wraps the message in a federation envelope
+     * with proper metadata for multi-hop routing. Otherwise, sends raw message
+     * for backwards compatibility.
+     *
+     * During reconnection, messages are buffered if buffer is configured.
+     */
+    routeToSystem(systemId: string, message: Message): Promise<FederationRouteResponseResult>;
+    /**
+     * Check if a remote system is connected
+     */
+    isSystemConnected(systemId: string): boolean;
+    /**
+     * Current connection state
+     */
+    get state(): ConnectionState;
+    /**
+     * Whether the connection is currently reconnecting
+     */
+    get isReconnecting(): boolean;
+    /**
+     * Get the outage buffer (for advanced use)
+     */
+    get outageBuffer(): FederationOutageBuffer | null;
+    /**
+     * Get last sync timestamp for a peer
+     */
+    getLastSyncTimestamp(peerId: string): number | undefined;
+    /**
+     * Register a handler for reconnection events.
+     *
+     * @param handler - Function called when reconnection events occur
+     * @returns Unsubscribe function to remove the handler
+     */
+    onReconnection(handler: GatewayReconnectionEventHandler): () => void;
+    /**
+     * Register a handler for connection state changes.
+     *
+     * @param handler - Function called when state changes
+     * @returns Unsubscribe function to remove the handler
+     */
+    onStateChange(handler: (newState: ConnectionState, oldState: ConnectionState) => void): () => void;
+}
+
+/**
+ * MAP Router Interface
+ *
+ * Defines the interface for implementing a MAP system router/server.
+ * The actual router implementation is not included in the SDK.
+ */
+
+/**
+ * Information about a connected participant
+ */
+interface ConnectedParticipant {
+    id: ParticipantId;
+    type: ParticipantType;
+    name?: string;
+    capabilities: ParticipantCapabilities;
+    sessionId: SessionId;
+    connectedAt: number;
+}
+/**
+ * Agent exposure configuration.
+ * Controls which agents are visible to external participants.
+ */
+interface AgentExposure {
+    /** Whether agents are public by default (default: true) */
+    publicByDefault?: boolean;
+    /** Glob patterns for agents that are always public */
+    publicAgents?: string[];
+    /** Glob patterns for agents that are always hidden (takes precedence over publicAgents) */
+    hiddenAgents?: string[];
+}
+/**
+ * Event exposure configuration.
+ * Controls which event types are visible to external participants.
+ */
+interface EventExposure {
+    /** Event types that are exposed (whitelist - if provided, only these types are visible) */
+    exposedTypes?: EventType[];
+    /** Event types that are always hidden (blacklist - takes precedence) */
+    hiddenTypes?: EventType[];
+}
+/**
+ * Scope exposure configuration.
+ * Controls which scopes are visible to external participants.
+ */
+interface ScopeExposure {
+    /** Whether scopes are public by default (default: true) */
+    publicByDefault?: boolean;
+    /** Glob patterns for scopes that are always public */
+    publicScopes?: string[];
+    /** Glob patterns for scopes that are always hidden (takes precedence over publicScopes) */
+    hiddenScopes?: string[];
+}
+/**
+ * System-level exposure configuration.
+ * Controls what entities are visible to participants at the system level (Layer 1).
+ */
+interface SystemExposure {
+    /** Agent visibility configuration */
+    agents?: AgentExposure;
+    /** Event visibility configuration */
+    events?: EventExposure;
+    /** Scope visibility configuration */
+    scopes?: ScopeExposure;
+}
+/**
+ * Resource limits for the router.
+ * Enforces capacity constraints to prevent resource exhaustion.
+ */
+interface RouterLimits {
+    /** Maximum total concurrent connections */
+    maxConnections?: number;
+    /** Maximum connections per unique client identity */
+    maxConnectionsPerClient?: number;
+    /** Maximum subscriptions per connection */
+    maxSubscriptionsPerConnection?: number;
+    /** Maximum agents a single client can register */
+    maxAgentsPerClient?: number;
+    /** Maximum scopes a single agent can join */
+    maxScopesPerAgent?: number;
+    /** Maximum events to retain for replay */
+    maxEventHistory?: number;
+}
+/**
+ * Router configuration
+ */
+interface MAPRouterConfig {
+    /** System name */
+    name?: string;
+    /** System version */
+    version?: string;
+    /** Default capabilities granted to clients */
+    defaultClientCapabilities?: ParticipantCapabilities;
+    /** Default capabilities granted to agents */
+    defaultAgentCapabilities?: ParticipantCapabilities;
+    /**
+     * System-level exposure configuration.
+     * Controls what entities are visible at Layer 1 of the permission model.
+     */
+    exposure?: SystemExposure;
+    /**
+     * Resource limits for the router.
+     */
+    limits?: RouterLimits;
+    /**
+     * Capabilities granted to anonymous/unauthenticated participants.
+     * If not set, anonymous connections may be rejected or granted minimal permissions.
+     */
+    anonymousCapabilities?: ParticipantCapabilities;
+    /** Authentication handler */
+    authenticate?: (participantType: ParticipantType, auth: {
+        method: string;
+        token?: string;
+    }) => Promise<{
+        allowed: boolean;
+        capabilities?: ParticipantCapabilities;
+    }>;
+}
+/**
+ * Interface for MAP router implementations.
+ *
+ * A router is the central component that:
+ * - Accepts connections from participants (clients, agents, gateways)
+ * - Routes messages between participants
+ * - Manages agent lifecycle
+ * - Handles subscriptions and event delivery
+ * - Enforces permissions and visibility
+ */
+interface MAPRouter {
+    /**
+     * Router configuration
+     */
+    readonly config: MAPRouterConfig;
+    /**
+     * Accept a new connection
+     */
+    acceptConnection(stream: Stream): Promise<ConnectedParticipant>;
+    /**
+     * Get all connected participants
+     */
+    getParticipants(): ConnectedParticipant[];
+    /**
+     * Get a specific participant
+     */
+    getParticipant(id: ParticipantId): ConnectedParticipant | undefined;
+    /**
+     * Disconnect a participant
+     */
+    disconnectParticipant(id: ParticipantId, reason?: string): Promise<void>;
+    /**
+     * Register a new agent
+     */
+    registerAgent(options: {
+        agentId?: AgentId;
+        name?: string;
+        role?: string;
+        parent?: AgentId;
+        scopes?: ScopeId[];
+        visibility?: string;
+        capabilities?: ParticipantCapabilities;
+        metadata?: Record<string, unknown>;
+    }): Promise<Agent>;
+    /**
+     * Get an agent by ID
+     */
+    getAgent(agentId: AgentId): Agent | undefined;
+    /**
+     * List agents with filters
+     */
+    listAgents(filter?: {
+        states?: string[];
+        roles?: string[];
+        scopes?: ScopeId[];
+        parent?: AgentId;
+    }): Agent[];
+    /**
+     * Update an agent
+     */
+    updateAgent(agentId: AgentId, updates: {
+        state?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<Agent>;
+    /**
+     * Unregister an agent
+     */
+    unregisterAgent(agentId: AgentId): Promise<void>;
+    /**
+     * Create a scope
+     */
+    createScope(options: {
+        scopeId?: ScopeId;
+        name?: string;
+        parent?: ScopeId;
+        joinPolicy?: string;
+        visibility?: string;
+        messageVisibility?: string;
+        sendPolicy?: string;
+    }): Promise<Scope>;
+    /**
+     * Get a scope by ID
+     */
+    getScope(scopeId: ScopeId): Scope | undefined;
+    /**
+     * List scopes
+     */
+    listScopes(filter?: {
+        parent?: ScopeId;
+    }): Scope[];
+    /**
+     * Delete a scope
+     */
+    deleteScope(scopeId: ScopeId): Promise<void>;
+    /**
+     * Add an agent to a scope
+     */
+    joinScope(scopeId: ScopeId, agentId: AgentId): Promise<void>;
+    /**
+     * Remove an agent from a scope
+     */
+    leaveScope(scopeId: ScopeId, agentId: AgentId): Promise<void>;
+    /**
+     * Get scope members
+     */
+    getScopeMembers(scopeId: ScopeId): AgentId[];
+    /**
+     * Route a message to its destination(s)
+     */
+    routeMessage(from: ParticipantId, to: Address, message: Message): Promise<{
+        delivered: ParticipantId[];
+    }>;
+    /**
+     * Create a subscription for a participant
+     */
+    createSubscription(participantId: ParticipantId, filter?: SubscriptionFilter): Promise<string>;
+    /**
+     * Remove a subscription
+     */
+    removeSubscription(subscriptionId: string): Promise<void>;
+    /**
+     * Emit an event to subscribers
+     */
+    emitEvent(event: Event): void;
+    /**
+     * Start the router
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the router
+     */
+    stop(): Promise<void>;
+}
+/**
+ * Factory type for creating MAP routers
+ */
+type MAPRouterFactory = (config?: MAPRouterConfig) => MAPRouter;
+
+/**
+ * Zod validators for MAP protocol types
+ *
+ * These validators provide runtime validation for protocol messages.
+ * They are generated based on the JSON schema but hand-tuned for proper Zod compatibility.
+ */
+
+declare const JsonRpcVersionSchema: z.ZodLiteral<"2.0">;
+declare const RequestIdSchema: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+declare const ProtocolVersionSchema: z.ZodLiteral<1>;
+declare const TimestampSchema: z.ZodNumber;
+declare const MetaSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+declare const ParticipantIdSchema: z.ZodString;
+declare const AgentIdSchema: z.ZodString;
+declare const ScopeIdSchema: z.ZodString;
+declare const SessionIdSchema: z.ZodString;
+declare const MessageIdSchema: z.ZodString;
+declare const SubscriptionIdSchema: z.ZodString;
+declare const CorrelationIdSchema: z.ZodString;
+declare const ParticipantTypeSchema: z.ZodEnum<["agent", "client", "system", "gateway"]>;
+declare const TransportTypeSchema: z.ZodEnum<["websocket", "stdio", "inprocess", "http-sse"]>;
+declare const ErrorCategorySchema: z.ZodEnum<["protocol", "auth", "routing", "agent", "resource", "federation", "internal"]>;
+declare const AgentVisibilitySchema: z.ZodEnum<["public", "parent-only", "scope", "system"]>;
+declare const AgentStateSchema: z.ZodUnion<[z.ZodEnum<["registered", "idle", "busy", "waiting", "stopping", "stopped", "error"]>, z.ZodString]>;
+declare const MessagePrioritySchema: z.ZodEnum<["low", "normal", "high", "urgent"]>;
+declare const DeliverySemanticsSchema: z.ZodEnum<["at-most-once", "at-least-once", "exactly-once"]>;
+declare const MessageRelationshipSchema: z.ZodEnum<["peer", "parent-to-child", "child-to-parent", "supervisor-to-supervised", "broadcast"]>;
+declare const EventTypeSchema: z.ZodEnum<["agent.registered", "agent.unregistered", "agent.state-changed", "agent.spawned", "scope.created", "scope.deleted", "scope.joined", "scope.left", "message.sent", "message.delivered", "session.started", "session.ended", "system.error", "system.shutdown"]>;
+declare const ScopeJoinPolicySchema: z.ZodEnum<["open", "approval", "invite"]>;
+declare const ScopeVisibilitySchema: z.ZodEnum<["public", "private", "unlisted"]>;
+declare const MessageVisibilitySchema: z.ZodEnum<["members", "public"]>;
+declare const ScopeSendPolicySchema: z.ZodEnum<["anyone", "members"]>;
+declare const ParticipantCapabilitiesSchema: z.ZodObject<{
+    observation: z.ZodOptional<z.ZodObject<{
+        canObserve: z.ZodOptional<z.ZodBoolean>;
+        canQuery: z.ZodOptional<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        canObserve?: boolean | undefined;
+        canQuery?: boolean | undefined;
+    }, {
+        canObserve?: boolean | undefined;
+        canQuery?: boolean | undefined;
+    }>>;
+    messaging: z.ZodOptional<z.ZodObject<{
+        canSend: z.ZodOptional<z.ZodBoolean>;
+        canReceive: z.ZodOptional<z.ZodBoolean>;
+        canBroadcast: z.ZodOptional<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        canSend?: boolean | undefined;
+        canReceive?: boolean | undefined;
+        canBroadcast?: boolean | undefined;
+    }, {
+        canSend?: boolean | undefined;
+        canReceive?: boolean | undefined;
+        canBroadcast?: boolean | undefined;
+    }>>;
+    lifecycle: z.ZodOptional<z.ZodObject<{
+        canSpawn: z.ZodOptional<z.ZodBoolean>;
+        canRegister: z.ZodOptional<z.ZodBoolean>;
+        canUnregister: z.ZodOptional<z.ZodBoolean>;
+        canSteer: z.ZodOptional<z.ZodBoolean>;
+        canStop: z.ZodOptional<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        canSpawn?: boolean | undefined;
+        canRegister?: boolean | undefined;
+        canUnregister?: boolean | undefined;
+        canSteer?: boolean | undefined;
+        canStop?: boolean | undefined;
+    }, {
+        canSpawn?: boolean | undefined;
+        canRegister?: boolean | undefined;
+        canUnregister?: boolean | undefined;
+        canSteer?: boolean | undefined;
+        canStop?: boolean | undefined;
+    }>>;
+    scopes: z.ZodOptional<z.ZodObject<{
+        canCreateScopes: z.ZodOptional<z.ZodBoolean>;
+        canManageScopes: z.ZodOptional<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        canCreateScopes?: boolean | undefined;
+        canManageScopes?: boolean | undefined;
+    }, {
+        canCreateScopes?: boolean | undefined;
+        canManageScopes?: boolean | undefined;
+    }>>;
+    _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strict", z.ZodTypeAny, {
+    _meta?: Record<string, unknown> | undefined;
+    scopes?: {
+        canCreateScopes?: boolean | undefined;
+        canManageScopes?: boolean | undefined;
+    } | undefined;
+    observation?: {
+        canObserve?: boolean | undefined;
+        canQuery?: boolean | undefined;
+    } | undefined;
+    messaging?: {
+        canSend?: boolean | undefined;
+        canReceive?: boolean | undefined;
+        canBroadcast?: boolean | undefined;
+    } | undefined;
+    lifecycle?: {
+        canSpawn?: boolean | undefined;
+        canRegister?: boolean | undefined;
+        canUnregister?: boolean | undefined;
+        canSteer?: boolean | undefined;
+        canStop?: boolean | undefined;
+    } | undefined;
+}, {
+    _meta?: Record<string, unknown> | undefined;
+    scopes?: {
+        canCreateScopes?: boolean | undefined;
+        canManageScopes?: boolean | undefined;
+    } | undefined;
+    observation?: {
+        canObserve?: boolean | undefined;
+        canQuery?: boolean | undefined;
+    } | undefined;
+    messaging?: {
+        canSend?: boolean | undefined;
+        canReceive?: boolean | undefined;
+        canBroadcast?: boolean | undefined;
+    } | undefined;
+    lifecycle?: {
+        canSpawn?: boolean | undefined;
+        canRegister?: boolean | undefined;
+        canUnregister?: boolean | undefined;
+        canSteer?: boolean | undefined;
+        canStop?: boolean | undefined;
+    } | undefined;
+}>;
+declare const DirectAddressSchema: z.ZodObject<{
+    agent: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    agent: string;
+}, {
+    agent: string;
+}>;
+declare const MultiAddressSchema: z.ZodObject<{
+    agents: z.ZodArray<z.ZodString, "many">;
+}, "strict", z.ZodTypeAny, {
+    agents: string[];
+}, {
+    agents: string[];
+}>;
+declare const ScopeAddressSchema: z.ZodObject<{
+    scope: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    scope: string;
+}, {
+    scope: string;
+}>;
+declare const RoleAddressSchema: z.ZodObject<{
+    role: z.ZodString;
+    scope: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    role: string;
+    scope?: string | undefined;
+}, {
+    role: string;
+    scope?: string | undefined;
+}>;
+declare const HierarchicalAddressSchema: z.ZodObject<{
+    parent: z.ZodOptional<z.ZodLiteral<true>>;
+    children: z.ZodOptional<z.ZodLiteral<true>>;
+    siblings: z.ZodOptional<z.ZodLiteral<true>>;
+    ancestors: z.ZodOptional<z.ZodLiteral<true>>;
+    descendants: z.ZodOptional<z.ZodLiteral<true>>;
+}, "strict", z.ZodTypeAny, {
+    parent?: true | undefined;
+    children?: true | undefined;
+    ancestors?: true | undefined;
+    descendants?: true | undefined;
+    siblings?: true | undefined;
+}, {
+    parent?: true | undefined;
+    children?: true | undefined;
+    ancestors?: true | undefined;
+    descendants?: true | undefined;
+    siblings?: true | undefined;
+}>;
+declare const BroadcastAddressSchema: z.ZodObject<{
+    broadcast: z.ZodLiteral<true>;
+}, "strict", z.ZodTypeAny, {
+    broadcast: true;
+}, {
+    broadcast: true;
+}>;
+declare const SystemAddressSchema: z.ZodObject<{
+    system: z.ZodLiteral<true>;
+}, "strict", z.ZodTypeAny, {
+    system: true;
+}, {
+    system: true;
+}>;
+declare const ParticipantAddressSchema: z.ZodObject<{
+    participant: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    participant: string;
+}, {
+    participant: string;
+}>;
+declare const FederatedAddressSchema: z.ZodObject<{
+    system: z.ZodString;
+    address: z.ZodLazy<z.ZodType<unknown, z.ZodTypeDef, unknown>>;
+}, "strict", z.ZodTypeAny, {
+    system: string;
+    address?: unknown;
+}, {
+    system: string;
+    address?: unknown;
+}>;
+declare const AddressSchema: z.ZodType<unknown>;
+declare const AgentRelationshipSchema: z.ZodObject<{
+    type: z.ZodEnum<["peer", "supervisor", "supervised", "collaborator"]>;
+    agentId: z.ZodString;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strict", z.ZodTypeAny, {
+    agentId: string;
+    type: "peer" | "supervisor" | "supervised" | "collaborator";
+    _meta?: Record<string, unknown> | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    agentId: string;
+    type: "peer" | "supervisor" | "supervised" | "collaborator";
+    _meta?: Record<string, unknown> | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+declare const AgentLifecycleSchema: z.ZodObject<{
+    createdAt: z.ZodOptional<z.ZodNumber>;
+    startedAt: z.ZodOptional<z.ZodNumber>;
+    stoppedAt: z.ZodOptional<z.ZodNumber>;
+    lastActiveAt: z.ZodOptional<z.ZodNumber>;
+    exitCode: z.ZodOptional<z.ZodNumber>;
+    exitReason: z.ZodOptional<z.ZodString>;
+    _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strict", z.ZodTypeAny, {
+    _meta?: Record<string, unknown> | undefined;
+    exitCode?: number | undefined;
+    exitReason?: string | undefined;
+    createdAt?: number | undefined;
+    startedAt?: number | undefined;
+    stoppedAt?: number | undefined;
+    lastActiveAt?: number | undefined;
+}, {
+    _meta?: Record<string, unknown> | undefined;
+    exitCode?: number | undefined;
+    exitReason?: string | undefined;
+    createdAt?: number | undefined;
+    startedAt?: number | undefined;
+    stoppedAt?: number | undefined;
+    lastActiveAt?: number | undefined;
+}>;
+declare const AgentSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    parent: z.ZodOptional<z.ZodString>;
+    relationships: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<["peer", "supervisor", "supervised", "collaborator"]>;
+        agentId: z.ZodString;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strict", z.ZodTypeAny, {
+        agentId: string;
+        type: "peer" | "supervisor" | "supervised" | "collaborator";
+        _meta?: Record<string, unknown> | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }, {
+        agentId: string;
+        type: "peer" | "supervisor" | "supervised" | "collaborator";
+        _meta?: Record<string, unknown> | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }>, "many">>;
+    state: z.ZodUnion<[z.ZodEnum<["registered", "idle", "busy", "waiting", "stopping", "stopped", "error"]>, z.ZodString]>;
+    role: z.ZodOptional<z.ZodString>;
+    scopes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    visibility: z.ZodOptional<z.ZodEnum<["public", "parent-only", "scope", "system"]>>;
+    lifecycle: z.ZodOptional<z.ZodObject<{
+        createdAt: z.ZodOptional<z.ZodNumber>;
+        startedAt: z.ZodOptional<z.ZodNumber>;
+        stoppedAt: z.ZodOptional<z.ZodNumber>;
+        lastActiveAt: z.ZodOptional<z.ZodNumber>;
+        exitCode: z.ZodOptional<z.ZodNumber>;
+        exitReason: z.ZodOptional<z.ZodString>;
+        _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strict", z.ZodTypeAny, {
+        _meta?: Record<string, unknown> | undefined;
+        exitCode?: number | undefined;
+        exitReason?: string | undefined;
+        createdAt?: number | undefined;
+        startedAt?: number | undefined;
+        stoppedAt?: number | undefined;
+        lastActiveAt?: number | undefined;
+    }, {
+        _meta?: Record<string, unknown> | undefined;
+        exitCode?: number | undefined;
+        exitReason?: string | undefined;
+        createdAt?: number | undefined;
+        startedAt?: number | undefined;
+        stoppedAt?: number | undefined;
+        lastActiveAt?: number | undefined;
+    }>>;
+    capabilities: z.ZodOptional<z.ZodObject<{
+        observation: z.ZodOptional<z.ZodObject<{
+            canObserve: z.ZodOptional<z.ZodBoolean>;
+            canQuery: z.ZodOptional<z.ZodBoolean>;
+        }, "strict", z.ZodTypeAny, {
+            canObserve?: boolean | undefined;
+            canQuery?: boolean | undefined;
+        }, {
+            canObserve?: boolean | undefined;
+            canQuery?: boolean | undefined;
+        }>>;
+        messaging: z.ZodOptional<z.ZodObject<{
+            canSend: z.ZodOptional<z.ZodBoolean>;
+            canReceive: z.ZodOptional<z.ZodBoolean>;
+            canBroadcast: z.ZodOptional<z.ZodBoolean>;
+        }, "strict", z.ZodTypeAny, {
+            canSend?: boolean | undefined;
+            canReceive?: boolean | undefined;
+            canBroadcast?: boolean | undefined;
+        }, {
+            canSend?: boolean | undefined;
+            canReceive?: boolean | undefined;
+            canBroadcast?: boolean | undefined;
+        }>>;
+        lifecycle: z.ZodOptional<z.ZodObject<{
+            canSpawn: z.ZodOptional<z.ZodBoolean>;
+            canRegister: z.ZodOptional<z.ZodBoolean>;
+            canUnregister: z.ZodOptional<z.ZodBoolean>;
+            canSteer: z.ZodOptional<z.ZodBoolean>;
+            canStop: z.ZodOptional<z.ZodBoolean>;
+        }, "strict", z.ZodTypeAny, {
+            canSpawn?: boolean | undefined;
+            canRegister?: boolean | undefined;
+            canUnregister?: boolean | undefined;
+            canSteer?: boolean | undefined;
+            canStop?: boolean | undefined;
+        }, {
+            canSpawn?: boolean | undefined;
+            canRegister?: boolean | undefined;
+            canUnregister?: boolean | undefined;
+            canSteer?: boolean | undefined;
+            canStop?: boolean | undefined;
+        }>>;
+        scopes: z.ZodOptional<z.ZodObject<{
+            canCreateScopes: z.ZodOptional<z.ZodBoolean>;
+            canManageScopes: z.ZodOptional<z.ZodBoolean>;
+        }, "strict", z.ZodTypeAny, {
+            canCreateScopes?: boolean | undefined;
+            canManageScopes?: boolean | undefined;
+        }, {
+            canCreateScopes?: boolean | undefined;
+            canManageScopes?: boolean | undefined;
+        }>>;
+        _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strict", z.ZodTypeAny, {
+        _meta?: Record<string, unknown> | undefined;
+        scopes?: {
+            canCreateScopes?: boolean | undefined;
+            canManageScopes?: boolean | undefined;
+        } | undefined;
+        observation?: {
+            canObserve?: boolean | undefined;
+            canQuery?: boolean | undefined;
+        } | undefined;
+        messaging?: {
+            canSend?: boolean | undefined;
+            canReceive?: boolean | undefined;
+            canBroadcast?: boolean | undefined;
+        } | undefined;
+        lifecycle?: {
+            canSpawn?: boolean | undefined;
+            canRegister?: boolean | undefined;
+            canUnregister?: boolean | undefined;
+            canSteer?: boolean | undefined;
+            canStop?: boolean | undefined;
+        } | undefined;
+    }, {
+        _meta?: Record<string, unknown> | undefined;
+        scopes?: {
+            canCreateScopes?: boolean | undefined;
+            canManageScopes?: boolean | undefined;
+        } | undefined;
+        observation?: {
+            canObserve?: boolean | undefined;
+            canQuery?: boolean | undefined;
+        } | undefined;
+        messaging?: {
+            canSend?: boolean | undefined;
+            canReceive?: boolean | undefined;
+            canBroadcast?: boolean | undefined;
+        } | undefined;
+        lifecycle?: {
+            canSpawn?: boolean | undefined;
+            canRegister?: boolean | undefined;
+            canUnregister?: boolean | undefined;
+            canSteer?: boolean | undefined;
+            canStop?: boolean | undefined;
+        } | undefined;
+    }>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    state: string;
+    role?: string | undefined;
+    parent?: string | undefined;
+    name?: string | undefined;
+    capabilities?: {
+        _meta?: Record<string, unknown> | undefined;
+        scopes?: {
+            canCreateScopes?: boolean | undefined;
+            canManageScopes?: boolean | undefined;
+        } | undefined;
+        observation?: {
+            canObserve?: boolean | undefined;
+            canQuery?: boolean | undefined;
+        } | undefined;
+        messaging?: {
+            canSend?: boolean | undefined;
+            canReceive?: boolean | undefined;
+            canBroadcast?: boolean | undefined;
+        } | undefined;
+        lifecycle?: {
+            canSpawn?: boolean | undefined;
+            canRegister?: boolean | undefined;
+            canUnregister?: boolean | undefined;
+            canSteer?: boolean | undefined;
+            canStop?: boolean | undefined;
+        } | undefined;
+    } | undefined;
+    _meta?: Record<string, unknown> | undefined;
+    visibility?: "system" | "public" | "parent-only" | "scope" | undefined;
+    scopes?: string[] | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    lifecycle?: {
+        _meta?: Record<string, unknown> | undefined;
+        exitCode?: number | undefined;
+        exitReason?: string | undefined;
+        createdAt?: number | undefined;
+        startedAt?: number | undefined;
+        stoppedAt?: number | undefined;
+        lastActiveAt?: number | undefined;
+    } | undefined;
+    description?: string | undefined;
+    relationships?: {
+        agentId: string;
+        type: "peer" | "supervisor" | "supervised" | "collaborator";
+        _meta?: Record<string, unknown> | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }[] | undefined;
+}, {
+    id: string;
+    state: string;
+    role?: string | undefined;
+    parent?: string | undefined;
+    name?: string | undefined;
+    capabilities?: {
+        _meta?: Record<string, unknown> | undefined;
+        scopes?: {
+            canCreateScopes?: boolean | undefined;
+            canManageScopes?: boolean | undefined;
+        } | undefined;
+        observation?: {
+            canObserve?: boolean | undefined;
+            canQuery?: boolean | undefined;
+        } | undefined;
+        messaging?: {
+            canSend?: boolean | undefined;
+            canReceive?: boolean | undefined;
+            canBroadcast?: boolean | undefined;
+        } | undefined;
+        lifecycle?: {
+            canSpawn?: boolean | undefined;
+            canRegister?: boolean | undefined;
+            canUnregister?: boolean | undefined;
+            canSteer?: boolean | undefined;
+            canStop?: boolean | undefined;
+        } | undefined;
+    } | undefined;
+    _meta?: Record<string, unknown> | undefined;
+    visibility?: "system" | "public" | "parent-only" | "scope" | undefined;
+    scopes?: string[] | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    lifecycle?: {
+        _meta?: Record<string, unknown> | undefined;
+        exitCode?: number | undefined;
+        exitReason?: string | undefined;
+        createdAt?: number | undefined;
+        startedAt?: number | undefined;
+        stoppedAt?: number | undefined;
+        lastActiveAt?: number | undefined;
+    } | undefined;
+    description?: string | undefined;
+    relationships?: {
+        agentId: string;
+        type: "peer" | "supervisor" | "supervised" | "collaborator";
+        _meta?: Record<string, unknown> | undefined;
+        metadata?: Record<string, unknown> | undefined;
+    }[] | undefined;
+}>;
+declare const ScopeSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    parent: z.ZodOptional<z.ZodString>;
+    children: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    joinPolicy: z.ZodOptional<z.ZodEnum<["open", "approval", "invite"]>>;
+    visibility: z.ZodOptional<z.ZodEnum<["public", "private", "unlisted"]>>;
+    messageVisibility: z.ZodOptional<z.ZodEnum<["members", "public"]>>;
+    sendPolicy: z.ZodOptional<z.ZodEnum<["anyone", "members"]>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    parent?: string | undefined;
+    children?: string[] | undefined;
+    name?: string | undefined;
+    _meta?: Record<string, unknown> | undefined;
+    visibility?: "public" | "private" | "unlisted" | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    joinPolicy?: "open" | "invite" | "approval" | undefined;
+    messageVisibility?: "public" | "members" | undefined;
+    sendPolicy?: "members" | "anyone" | undefined;
+}, {
+    id: string;
+    parent?: string | undefined;
+    children?: string[] | undefined;
+    name?: string | undefined;
+    _meta?: Record<string, unknown> | undefined;
+    visibility?: "public" | "private" | "unlisted" | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    joinPolicy?: "open" | "invite" | "approval" | undefined;
+    messageVisibility?: "public" | "members" | undefined;
+    sendPolicy?: "members" | "anyone" | undefined;
+}>;
+declare const MessageMetaSchema: z.ZodObject<{
+    correlationId: z.ZodOptional<z.ZodString>;
+    causationId: z.ZodOptional<z.ZodString>;
+    traceId: z.ZodOptional<z.ZodString>;
+    spanId: z.ZodOptional<z.ZodString>;
+    priority: z.ZodOptional<z.ZodEnum<["low", "normal", "high", "urgent"]>>;
+    delivery: z.ZodOptional<z.ZodEnum<["at-most-once", "at-least-once", "exactly-once"]>>;
+    relationship: z.ZodOptional<z.ZodEnum<["peer", "parent-to-child", "child-to-parent", "supervisor-to-supervised", "broadcast"]>>;
+    expiresAt: z.ZodOptional<z.ZodNumber>;
+    isResult: z.ZodOptional<z.ZodBoolean>;
+    _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strict", z.ZodTypeAny, {
+    _meta?: Record<string, unknown> | undefined;
+    correlationId?: string | undefined;
+    relationship?: "peer" | "parent-to-child" | "child-to-parent" | "broadcast" | "supervisor-to-supervised" | undefined;
+    isResult?: boolean | undefined;
+    causationId?: string | undefined;
+    traceId?: string | undefined;
+    spanId?: string | undefined;
+    priority?: "urgent" | "high" | "normal" | "low" | undefined;
+    delivery?: "at-most-once" | "at-least-once" | "exactly-once" | undefined;
+    expiresAt?: number | undefined;
+}, {
+    _meta?: Record<string, unknown> | undefined;
+    correlationId?: string | undefined;
+    relationship?: "peer" | "parent-to-child" | "child-to-parent" | "broadcast" | "supervisor-to-supervised" | undefined;
+    isResult?: boolean | undefined;
+    causationId?: string | undefined;
+    traceId?: string | undefined;
+    spanId?: string | undefined;
+    priority?: "urgent" | "high" | "normal" | "low" | undefined;
+    delivery?: "at-most-once" | "at-least-once" | "exactly-once" | undefined;
+    expiresAt?: number | undefined;
+}>;
+declare const MessageSchema: z.ZodObject<{
+    id: z.ZodString;
+    from: z.ZodString;
+    to: z.ZodType<unknown, z.ZodTypeDef, unknown>;
+    timestamp: z.ZodNumber;
+    payload: z.ZodOptional<z.ZodUnknown>;
+    meta: z.ZodOptional<z.ZodObject<{
+        correlationId: z.ZodOptional<z.ZodString>;
+        causationId: z.ZodOptional<z.ZodString>;
+        traceId: z.ZodOptional<z.ZodString>;
+        spanId: z.ZodOptional<z.ZodString>;
+        priority: z.ZodOptional<z.ZodEnum<["low", "normal", "high", "urgent"]>>;
+        delivery: z.ZodOptional<z.ZodEnum<["at-most-once", "at-least-once", "exactly-once"]>>;
+        relationship: z.ZodOptional<z.ZodEnum<["peer", "parent-to-child", "child-to-parent", "supervisor-to-supervised", "broadcast"]>>;
+        expiresAt: z.ZodOptional<z.ZodNumber>;
+        isResult: z.ZodOptional<z.ZodBoolean>;
+        _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strict", z.ZodTypeAny, {
+        _meta?: Record<string, unknown> | undefined;
+        correlationId?: string | undefined;
+        relationship?: "peer" | "parent-to-child" | "child-to-parent" | "broadcast" | "supervisor-to-supervised" | undefined;
+        isResult?: boolean | undefined;
+        causationId?: string | undefined;
+        traceId?: string | undefined;
+        spanId?: string | undefined;
+        priority?: "urgent" | "high" | "normal" | "low" | undefined;
+        delivery?: "at-most-once" | "at-least-once" | "exactly-once" | undefined;
+        expiresAt?: number | undefined;
+    }, {
+        _meta?: Record<string, unknown> | undefined;
+        correlationId?: string | undefined;
+        relationship?: "peer" | "parent-to-child" | "child-to-parent" | "broadcast" | "supervisor-to-supervised" | undefined;
+        isResult?: boolean | undefined;
+        causationId?: string | undefined;
+        traceId?: string | undefined;
+        spanId?: string | undefined;
+        priority?: "urgent" | "high" | "normal" | "low" | undefined;
+        delivery?: "at-most-once" | "at-least-once" | "exactly-once" | undefined;
+        expiresAt?: number | undefined;
+    }>>;
+    _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    timestamp: number;
+    from: string;
+    _meta?: Record<string, unknown> | undefined;
+    meta?: {
+        _meta?: Record<string, unknown> | undefined;
+        correlationId?: string | undefined;
+        relationship?: "peer" | "parent-to-child" | "child-to-parent" | "broadcast" | "supervisor-to-supervised" | undefined;
+        isResult?: boolean | undefined;
+        causationId?: string | undefined;
+        traceId?: string | undefined;
+        spanId?: string | undefined;
+        priority?: "urgent" | "high" | "normal" | "low" | undefined;
+        delivery?: "at-most-once" | "at-least-once" | "exactly-once" | undefined;
+        expiresAt?: number | undefined;
+    } | undefined;
+    payload?: unknown;
+    to?: unknown;
+}, {
+    id: string;
+    timestamp: number;
+    from: string;
+    _meta?: Record<string, unknown> | undefined;
+    meta?: {
+        _meta?: Record<string, unknown> | undefined;
+        correlationId?: string | undefined;
+        relationship?: "peer" | "parent-to-child" | "child-to-parent" | "broadcast" | "supervisor-to-supervised" | undefined;
+        isResult?: boolean | undefined;
+        causationId?: string | undefined;
+        traceId?: string | undefined;
+        spanId?: string | undefined;
+        priority?: "urgent" | "high" | "normal" | "low" | undefined;
+        delivery?: "at-most-once" | "at-least-once" | "exactly-once" | undefined;
+        expiresAt?: number | undefined;
+    } | undefined;
+    payload?: unknown;
+    to?: unknown;
+}>;
+declare const EventSchema: z.ZodObject<{
+    type: z.ZodEnum<["agent.registered", "agent.unregistered", "agent.state-changed", "agent.spawned", "scope.created", "scope.deleted", "scope.joined", "scope.left", "message.sent", "message.delivered", "session.started", "session.ended", "system.error", "system.shutdown"]>;
+    timestamp: z.ZodNumber;
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strict", z.ZodTypeAny, {
+    timestamp: number;
+    type: "agent.registered" | "agent.unregistered" | "agent.state-changed" | "agent.spawned" | "scope.created" | "scope.deleted" | "scope.joined" | "scope.left" | "message.sent" | "message.delivered" | "session.started" | "session.ended" | "system.error" | "system.shutdown";
+    data?: Record<string, unknown> | undefined;
+    _meta?: Record<string, unknown> | undefined;
+}, {
+    timestamp: number;
+    type: "agent.registered" | "agent.unregistered" | "agent.state-changed" | "agent.spawned" | "scope.created" | "scope.deleted" | "scope.joined" | "scope.left" | "message.sent" | "message.delivered" | "session.started" | "session.ended" | "system.error" | "system.shutdown";
+    data?: Record<string, unknown> | undefined;
+    _meta?: Record<string, unknown> | undefined;
+}>;
+declare const SubscriptionFilterSchema: z.ZodObject<{
+    eventTypes: z.ZodOptional<z.ZodArray<z.ZodEnum<["agent.registered", "agent.unregistered", "agent.state-changed", "agent.spawned", "scope.created", "scope.deleted", "scope.joined", "scope.left", "message.sent", "message.delivered", "session.started", "session.ended", "system.error", "system.shutdown"]>, "many">>;
+    scopes: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    agents: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    includeChildren: z.ZodOptional<z.ZodBoolean>;
+    _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strict", z.ZodTypeAny, {
+    agents?: string[] | undefined;
+    _meta?: Record<string, unknown> | undefined;
+    scopes?: string[] | undefined;
+    eventTypes?: ("agent.registered" | "agent.unregistered" | "agent.state-changed" | "agent.spawned" | "scope.created" | "scope.deleted" | "scope.joined" | "scope.left" | "message.sent" | "message.delivered" | "session.started" | "session.ended" | "system.error" | "system.shutdown")[] | undefined;
+    includeChildren?: boolean | undefined;
+}, {
+    agents?: string[] | undefined;
+    _meta?: Record<string, unknown> | undefined;
+    scopes?: string[] | undefined;
+    eventTypes?: ("agent.registered" | "agent.unregistered" | "agent.state-changed" | "agent.spawned" | "scope.created" | "scope.deleted" | "scope.joined" | "scope.left" | "message.sent" | "message.delivered" | "session.started" | "session.ended" | "system.error" | "system.shutdown")[] | undefined;
+    includeChildren?: boolean | undefined;
+}>;
+declare const MAPErrorDataSchema: z.ZodObject<{
+    category: z.ZodOptional<z.ZodEnum<["protocol", "auth", "routing", "agent", "resource", "federation", "internal"]>>;
+    retryable: z.ZodOptional<z.ZodBoolean>;
+    retryAfterMs: z.ZodOptional<z.ZodNumber>;
+    details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    category: z.ZodOptional<z.ZodEnum<["protocol", "auth", "routing", "agent", "resource", "federation", "internal"]>>;
+    retryable: z.ZodOptional<z.ZodBoolean>;
+    retryAfterMs: z.ZodOptional<z.ZodNumber>;
+    details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    category: z.ZodOptional<z.ZodEnum<["protocol", "auth", "routing", "agent", "resource", "federation", "internal"]>>;
+    retryable: z.ZodOptional<z.ZodBoolean>;
+    retryAfterMs: z.ZodOptional<z.ZodNumber>;
+    details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.ZodTypeAny, "passthrough">>;
+declare const MAPErrorSchema: z.ZodObject<{
+    code: z.ZodNumber;
+    message: z.ZodString;
+    data: z.ZodOptional<z.ZodObject<{
+        category: z.ZodOptional<z.ZodEnum<["protocol", "auth", "routing", "agent", "resource", "federation", "internal"]>>;
+        retryable: z.ZodOptional<z.ZodBoolean>;
+        retryAfterMs: z.ZodOptional<z.ZodNumber>;
+        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        category: z.ZodOptional<z.ZodEnum<["protocol", "auth", "routing", "agent", "resource", "federation", "internal"]>>;
+        retryable: z.ZodOptional<z.ZodBoolean>;
+        retryAfterMs: z.ZodOptional<z.ZodNumber>;
+        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        category: z.ZodOptional<z.ZodEnum<["protocol", "auth", "routing", "agent", "resource", "federation", "internal"]>>;
+        retryable: z.ZodOptional<z.ZodBoolean>;
+        retryAfterMs: z.ZodOptional<z.ZodNumber>;
+        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.ZodTypeAny, "passthrough">>>;
+}, "strict", z.ZodTypeAny, {
+    message: string;
+    code: number;
+    data?: z.objectOutputType<{
+        category: z.ZodOptional<z.ZodEnum<["protocol", "auth", "routing", "agent", "resource", "federation", "internal"]>>;
+        retryable: z.ZodOptional<z.ZodBoolean>;
+        retryAfterMs: z.ZodOptional<z.ZodNumber>;
+        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+}, {
+    message: string;
+    code: number;
+    data?: z.objectInputType<{
+        category: z.ZodOptional<z.ZodEnum<["protocol", "auth", "routing", "agent", "resource", "federation", "internal"]>>;
+        retryable: z.ZodOptional<z.ZodBoolean>;
+        retryAfterMs: z.ZodOptional<z.ZodNumber>;
+        details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.ZodTypeAny, "passthrough"> | undefined;
+}>;
+declare const MAPRequestSchema: z.ZodObject<{
+    jsonrpc: z.ZodLiteral<"2.0">;
+    id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    method: z.ZodString;
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strict", z.ZodTypeAny, {
+    jsonrpc: "2.0";
+    id: string | number;
+    method: string;
+    params?: Record<string, unknown> | undefined;
+}, {
+    jsonrpc: "2.0";
+    id: string | number;
+    method: string;
+    params?: Record<string, unknown> | undefined;
+}>;
+declare const MAPResponseSuccessSchema: z.ZodObject<{
+    jsonrpc: z.ZodLiteral<"2.0">;
+    id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    result: z.ZodUnknown;
+}, "strict", z.ZodTypeAny, {
+    jsonrpc: "2.0";
+    id: string | number;
+    result?: unknown;
+}, {
+    jsonrpc: "2.0";
+    id: string | number;
+    result?: unknown;
+}>;
+declare const MAPResponseErrorSchema: z.ZodObject<{
+    jsonrpc: z.ZodLiteral<"2.0">;
+    id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    error: z.ZodObject<{
+        code: z.ZodNumber;
+        message: z.ZodString;
+        data: z.ZodOptional<z.ZodObject<{
+            category: z.ZodOptional<z.ZodEnum<["protocol", "auth", "routing", "agent", "resource", "federation", "internal"]>>;
+            retryable: z.ZodOptional<z.ZodBoolean>;
+            retryAfterMs: z.ZodOptional<z.ZodNumber>;
+            details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            category: z.ZodOptional<z.ZodEnum<["protocol", "auth", "routing", "agent", "resource", "federation", "internal"]>>;
+            retryable: z.ZodOptional<z.ZodBoolean>;
+            retryAfterMs: z.ZodOptional<z.ZodNumber>;
+            details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            category: z.ZodOptional<z.ZodEnum<["protocol", "auth", "routing", "agent", "resource", "federation", "internal"]>>;
+            retryable: z.ZodOptional<z.ZodBoolean>;
+            retryAfterMs: z.ZodOptional<z.ZodNumber>;
+            details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.ZodTypeAny, "passthrough">>>;
+    }, "strict", z.ZodTypeAny, {
+        message: string;
+        code: number;
+        data?: z.objectOutputType<{
+            category: z.ZodOptional<z.ZodEnum<["protocol", "auth", "routing", "agent", "resource", "federation", "internal"]>>;
+            retryable: z.ZodOptional<z.ZodBoolean>;
+            retryAfterMs: z.ZodOptional<z.ZodNumber>;
+            details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+    }, {
+        message: string;
+        code: number;
+        data?: z.objectInputType<{
+            category: z.ZodOptional<z.ZodEnum<["protocol", "auth", "routing", "agent", "resource", "federation", "internal"]>>;
+            retryable: z.ZodOptional<z.ZodBoolean>;
+            retryAfterMs: z.ZodOptional<z.ZodNumber>;
+            details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    error: {
+        message: string;
+        code: number;
+        data?: z.objectOutputType<{
+            category: z.ZodOptional<z.ZodEnum<["protocol", "auth", "routing", "agent", "resource", "federation", "internal"]>>;
+            retryable: z.ZodOptional<z.ZodBoolean>;
+            retryAfterMs: z.ZodOptional<z.ZodNumber>;
+            details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+    };
+    jsonrpc: "2.0";
+    id: string | number;
+}, {
+    error: {
+        message: string;
+        code: number;
+        data?: z.objectInputType<{
+            category: z.ZodOptional<z.ZodEnum<["protocol", "auth", "routing", "agent", "resource", "federation", "internal"]>>;
+            retryable: z.ZodOptional<z.ZodBoolean>;
+            retryAfterMs: z.ZodOptional<z.ZodNumber>;
+            details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+    };
+    jsonrpc: "2.0";
+    id: string | number;
+}>;
+declare const MAPResponseSchema: z.ZodUnion<[z.ZodObject<{
+    jsonrpc: z.ZodLiteral<"2.0">;
+    id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    result: z.ZodUnknown;
+}, "strict", z.ZodTypeAny, {
+    jsonrpc: "2.0";
+    id: string | number;
+    result?: unknown;
+}, {
+    jsonrpc: "2.0";
+    id: string | number;
+    result?: unknown;
+}>, z.ZodObject<{
+    jsonrpc: z.ZodLiteral<"2.0">;
+    id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    error: z.ZodObject<{
+        code: z.ZodNumber;
+        message: z.ZodString;
+        data: z.ZodOptional<z.ZodObject<{
+            category: z.ZodOptional<z.ZodEnum<["protocol", "auth", "routing", "agent", "resource", "federation", "internal"]>>;
+            retryable: z.ZodOptional<z.ZodBoolean>;
+            retryAfterMs: z.ZodOptional<z.ZodNumber>;
+            details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            category: z.ZodOptional<z.ZodEnum<["protocol", "auth", "routing", "agent", "resource", "federation", "internal"]>>;
+            retryable: z.ZodOptional<z.ZodBoolean>;
+            retryAfterMs: z.ZodOptional<z.ZodNumber>;
+            details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            category: z.ZodOptional<z.ZodEnum<["protocol", "auth", "routing", "agent", "resource", "federation", "internal"]>>;
+            retryable: z.ZodOptional<z.ZodBoolean>;
+            retryAfterMs: z.ZodOptional<z.ZodNumber>;
+            details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.ZodTypeAny, "passthrough">>>;
+    }, "strict", z.ZodTypeAny, {
+        message: string;
+        code: number;
+        data?: z.objectOutputType<{
+            category: z.ZodOptional<z.ZodEnum<["protocol", "auth", "routing", "agent", "resource", "federation", "internal"]>>;
+            retryable: z.ZodOptional<z.ZodBoolean>;
+            retryAfterMs: z.ZodOptional<z.ZodNumber>;
+            details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+    }, {
+        message: string;
+        code: number;
+        data?: z.objectInputType<{
+            category: z.ZodOptional<z.ZodEnum<["protocol", "auth", "routing", "agent", "resource", "federation", "internal"]>>;
+            retryable: z.ZodOptional<z.ZodBoolean>;
+            retryAfterMs: z.ZodOptional<z.ZodNumber>;
+            details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    error: {
+        message: string;
+        code: number;
+        data?: z.objectOutputType<{
+            category: z.ZodOptional<z.ZodEnum<["protocol", "auth", "routing", "agent", "resource", "federation", "internal"]>>;
+            retryable: z.ZodOptional<z.ZodBoolean>;
+            retryAfterMs: z.ZodOptional<z.ZodNumber>;
+            details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+    };
+    jsonrpc: "2.0";
+    id: string | number;
+}, {
+    error: {
+        message: string;
+        code: number;
+        data?: z.objectInputType<{
+            category: z.ZodOptional<z.ZodEnum<["protocol", "auth", "routing", "agent", "resource", "federation", "internal"]>>;
+            retryable: z.ZodOptional<z.ZodBoolean>;
+            retryAfterMs: z.ZodOptional<z.ZodNumber>;
+            details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            _meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.ZodTypeAny, "passthrough"> | undefined;
+    };
+    jsonrpc: "2.0";
+    id: string | number;
+}>]>;
+declare const MAPNotificationSchema: z.ZodObject<{
+    jsonrpc: z.ZodLiteral<"2.0">;
+    method: z.ZodString;
+    params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strict", z.ZodTypeAny, {
+    jsonrpc: "2.0";
+    method: string;
+    params?: Record<string, unknown> | undefined;
+}, {
+    jsonrpc: "2.0";
+    method: string;
+    params?: Record<string, unknown> | undefined;
+}>;
+type ParticipantIdValidated = z.infer<typeof ParticipantIdSchema>;
+type AgentIdValidated = z.infer<typeof AgentIdSchema>;
+type ScopeIdValidated = z.infer<typeof ScopeIdSchema>;
+type SessionIdValidated = z.infer<typeof SessionIdSchema>;
+type MessageIdValidated = z.infer<typeof MessageIdSchema>;
+type ParticipantTypeValidated = z.infer<typeof ParticipantTypeSchema>;
+type AgentStateValidated = z.infer<typeof AgentStateSchema>;
+type AgentValidated = z.infer<typeof AgentSchema>;
+type ScopeValidated = z.infer<typeof ScopeSchema>;
+type MessageValidated = z.infer<typeof MessageSchema>;
+type EventValidated = z.infer<typeof EventSchema>;
+type AddressValidated = z.infer<typeof AddressSchema>;
+type MAPRequestValidated = z.infer<typeof MAPRequestSchema>;
+type MAPResponseValidated = z.infer<typeof MAPResponseSchema>;
+type MAPNotificationValidated = z.infer<typeof MAPNotificationSchema>;
+type MAPErrorValidated = z.infer<typeof MAPErrorSchema>;
+type ParticipantCapabilitiesValidated = z.infer<typeof ParticipantCapabilitiesSchema>;
+type SubscriptionFilterValidated = z.infer<typeof SubscriptionFilterSchema>;
+
+/**
+ * Protocol utilities for MAP SDK
+ *
+ * Provides:
+ * - METHOD_REGISTRY: Single source of truth for all methods with metadata
+ * - Response builders: Type-safe response construction
+ * - Helper functions for method capability checking
+ */
+
+/** Method category for organization */
+type MethodCategory = 'core' | 'observation' | 'lifecycle' | 'state' | 'steering' | 'scope' | 'session' | 'auth' | 'federation' | 'notification';
+/** Capability path like 'observation.canQuery' */
+type CapabilityPath = string;
+/** Method metadata */
+interface MethodInfo {
+    /** The wire method name */
+    method: string;
+    /** Category for organization */
+    category: MethodCategory;
+    /** Required capabilities (empty = no special capabilities needed) */
+    capabilities: CapabilityPath[];
+    /** Human-readable description */
+    description: string;
+}
+/**
+ * Method Registry - Single source of truth for all MAP methods
+ *
+ * Use this instead of individual method constants for:
+ * - Capability checking
+ * - Method validation
+ * - Documentation generation
+ */
+declare const METHOD_REGISTRY: Record<string, MethodInfo>;
+/**
+ * Get methods by category
+ */
+declare function getMethodsByCategory(category: MethodCategory): MethodInfo[];
+/**
+ * Get required capabilities for a method
+ */
+declare function getRequiredCapabilities(methodName: string): CapabilityPath[];
+/**
+ * Check if capabilities satisfy method requirements
+ */
+declare function hasRequiredCapabilities(methodName: string, capabilities: ParticipantCapabilities): boolean;
+/**
+ * Get method info by wire method name (e.g., 'map/agents/list')
+ */
+declare function getMethodInfo(wireMethod: string): MethodInfo | undefined;
+/**
+ * Build connect response
+ */
+declare function buildConnectResponse(params: {
+    protocolVersion: ProtocolVersion;
+    sessionId: SessionId;
+    participantId: ParticipantId;
+    capabilities: ParticipantCapabilities;
+    systemInfo?: {
+        name?: string;
+        version?: string;
+    };
+    reconnected?: boolean;
+    reclaimedAgents?: Agent[];
+    ownedAgents?: string[];
+}): ConnectResponseResult;
+/**
+ * Build disconnect response
+ */
+declare function buildDisconnectResponse(session: SessionInfo): DisconnectResponseResult;
+/**
+ * Build send response
+ */
+declare function buildSendResponse(messageId: MessageId, delivered: ParticipantId[]): SendResponseResult;
+/**
+ * Build agents/register response
+ */
+declare function buildAgentsRegisterResponse(agent: Agent): AgentsRegisterResponseResult;
+/**
+ * Build agents/unregister response
+ */
+declare function buildAgentsUnregisterResponse(agent: Agent): AgentsUnregisterResponseResult;
+/**
+ * Build agents/list response
+ */
+declare function buildAgentsListResponse(agents: Agent[]): AgentsListResponseResult;
+/**
+ * Build agents/get response
+ */
+declare function buildAgentsGetResponse(agent: Agent, children?: Agent[], descendants?: Agent[]): AgentsGetResponseResult;
+/**
+ * Build agents/update response
+ */
+declare function buildAgentsUpdateResponse(agent: Agent): AgentsUpdateResponseResult;
+/**
+ * Build agents/spawn response
+ */
+declare function buildAgentsSpawnResponse(agent: Agent): AgentsSpawnResponseResult;
+/**
+ * Build scopes/create response
+ */
+declare function buildScopesCreateResponse(scope: Scope): ScopesCreateResponseResult;
+/**
+ * Build scopes/list response
+ */
+declare function buildScopesListResponse(scopes: Scope[]): ScopesListResponseResult;
+/**
+ * Build scopes/join response
+ */
+declare function buildScopesJoinResponse(scope: Scope, agent: Agent): ScopesJoinResponseResult;
+/**
+ * Build scopes/leave response
+ */
+declare function buildScopesLeaveResponse(scope: Scope, agent: Agent): ScopesLeaveResponseResult;
+/**
+ * Build subscribe response
+ */
+declare function buildSubscribeResponse(subscriptionId: SubscriptionId): SubscribeResponseResult;
+/**
+ * Build unsubscribe response
+ */
+declare function buildUnsubscribeResponse(subscriptionId: SubscriptionId, closedAt?: number): UnsubscribeResponseResult;
+
+/**
+ * ULID utilities for MAP event IDs
+ *
+ * ULIDs (Universally Unique Lexicographically Sortable Identifiers) are:
+ * - 26 characters, Crockford Base32 encoded
+ * - Time-sortable (first 48 bits = millisecond timestamp)
+ * - Lexicographically sortable (string comparison = chronological order)
+ *
+ * Format: TTTTTTTTTTRRRRRRRRRRRRRRR
+ *         |---------|-------------|
+ *         Timestamp    Randomness
+ *         (10 chars)   (16 chars)
+ *
+ * @example
+ * ```typescript
+ * import { ulid, ulidTimestamp, compareUlid } from './utils/ulid';
+ *
+ * const id = ulid();  // "01HQJY3KCNP5VXWZ8M4R6T2G9B"
+ * const ts = ulidTimestamp(id);  // 1706123456789
+ * ```
+ */
+
+/**
+ * Extract the timestamp from a ULID.
+ *
+ * @param id - The ULID string
+ * @returns Unix timestamp in milliseconds
+ *
+ * @example
+ * ```typescript
+ * const id = ulid();
+ * const timestamp = ulidTimestamp(id);
+ * console.log(new Date(timestamp));
+ * ```
+ */
+declare function ulidTimestamp(id: string): number;
+/**
+ * Compare two ULIDs lexicographically.
+ *
+ * Since ULIDs are designed to be lexicographically sortable,
+ * this comparison also gives chronological ordering.
+ *
+ * @param a - First ULID
+ * @param b - Second ULID
+ * @returns Negative if a < b, positive if a > b, zero if equal
+ *
+ * @example
+ * ```typescript
+ * const ids = [ulid(), ulid(), ulid()];
+ * ids.sort(compareUlid);  // Chronological order
+ * ```
+ */
+declare function compareUlid(a: string, b: string): number;
+/**
+ * Check if a string is a valid ULID format.
+ *
+ * @param id - String to check
+ * @returns True if valid ULID format
+ */
+declare function isValidUlid(id: string): boolean;
+
+/**
+ * Retry utilities with exponential backoff
+ *
+ * Provides configurable retry logic for handling transient failures
+ * in network operations like reconnection.
+ */
+/**
+ * Configuration for retry behavior
+ */
+interface RetryPolicy {
+    /** Maximum number of retry attempts (default: 10) */
+    maxRetries: number;
+    /** Initial delay in milliseconds (default: 1000) */
+    baseDelayMs: number;
+    /** Maximum delay in milliseconds (default: 30000) */
+    maxDelayMs: number;
+    /** Add randomness to delay to prevent thundering herd (default: true) */
+    jitter: boolean;
+    /** Custom function to determine if an error is retryable */
+    isRetryable?: (error: Error) => boolean;
+}
+/**
+ * Default retry policy with sensible defaults for network operations
+ */
+declare const DEFAULT_RETRY_POLICY: RetryPolicy;
+/**
+ * State passed to retry callbacks
+ */
+interface RetryState {
+    /** Current attempt number (1-indexed) */
+    attempt: number;
+    /** Delay before next retry in milliseconds */
+    nextDelayMs: number;
+    /** The error that caused this retry */
+    lastError?: Error;
+}
+/**
+ * Callbacks for monitoring retry progress
+ */
+interface RetryCallbacks<T> {
+    /** Called before each retry attempt */
+    onRetry?: (state: RetryState) => void;
+    /** Called on successful completion */
+    onSuccess?: (result: T, attempts: number) => void;
+    /** Called when all retries are exhausted */
+    onFailure?: (error: Error, attempts: number) => void;
+}
+/**
+ * Calculate delay for a retry attempt using exponential backoff.
+ *
+ * Formula: min(baseDelay * 2^(attempt-1), maxDelay) * jitter
+ *
+ * @param attempt - Current attempt number (1-indexed)
+ * @param policy - Retry policy configuration
+ * @returns Delay in milliseconds
+ *
+ * @example
+ * ```typescript
+ * // With baseDelay=1000, maxDelay=30000:
+ * // Attempt 1: 1000ms
+ * // Attempt 2: 2000ms
+ * // Attempt 3: 4000ms
+ * // Attempt 4: 8000ms
+ * // Attempt 5: 16000ms
+ * // Attempt 6+: 30000ms (capped)
+ * ```
+ */
+declare function calculateDelay(attempt: number, policy: RetryPolicy): number;
+/**
+ * Execute an async operation with retry logic.
+ *
+ * Retries the operation on failure using exponential backoff until
+ * either it succeeds or the maximum retries are exhausted.
+ *
+ * @param operation - Async function to execute
+ * @param policy - Retry policy (defaults to DEFAULT_RETRY_POLICY)
+ * @param callbacks - Optional callbacks for monitoring progress
+ * @returns The result of the successful operation
+ * @throws The last error if all retries are exhausted
+ *
+ * @example
+ * ```typescript
+ * const result = await withRetry(
+ *   () => fetch('https://api.example.com/data'),
+ *   { maxRetries: 3, baseDelayMs: 1000, maxDelayMs: 5000, jitter: true },
+ *   {
+ *     onRetry: ({ attempt, nextDelayMs }) => {
+ *       console.log(`Retry ${attempt}, waiting ${nextDelayMs}ms`);
+ *     },
+ *   }
+ * );
+ * ```
+ */
+declare function withRetry<T>(operation: () => Promise<T>, policy?: RetryPolicy, callbacks?: RetryCallbacks<T>): Promise<T>;
+/**
+ * Create a retryable wrapper around an async function.
+ *
+ * Returns a new function with the same signature that automatically
+ * retries on failure according to the policy.
+ *
+ * @param fn - Async function to wrap
+ * @param policy - Retry policy
+ * @returns Wrapped function with retry behavior
+ *
+ * @example
+ * ```typescript
+ * const fetchWithRetry = retryable(
+ *   async (url: string) => fetch(url),
+ *   { maxRetries: 3, baseDelayMs: 1000, maxDelayMs: 5000, jitter: true }
+ * );
+ *
+ * const response = await fetchWithRetry('https://api.example.com');
+ * ```
+ */
+declare function retryable<TArgs extends unknown[], TResult>(fn: (...args: TArgs) => Promise<TResult>, policy?: RetryPolicy): (...args: TArgs) => Promise<TResult>;
+/**
+ * Create a partial retry policy merged with defaults.
+ *
+ * @param options - Partial policy options to override defaults
+ * @returns Complete retry policy
+ */
+declare function createRetryPolicy(options?: Partial<RetryPolicy>): RetryPolicy;
+/**
+ * Sleep for a specified duration.
+ *
+ * @param ms - Duration in milliseconds
+ * @returns Promise that resolves after the duration
+ */
+declare function sleep(ms: number): Promise<void>;
+
+/**
+ * Causal Event Buffer
+ *
+ * Buffers events and releases them in causal order. Events with `causedBy`
+ * dependencies are held until all their predecessor events have been seen.
+ *
+ * This is useful for:
+ * - Ensuring events are processed in correct causal order
+ * - Handling out-of-order event delivery
+ * - Building consistent views from event streams
+ */
+
+/**
+ * Event with envelope metadata for causal tracking
+ */
+interface CausalEvent {
+    /** Unique event identifier */
+    eventId: string;
+    /** Event IDs that must be processed before this event */
+    causedBy?: string[];
+    /** The event payload */
+    event: Event;
+    /** Timestamp when the event was received */
+    receivedAt?: number;
+}
+/**
+ * Options for CausalEventBuffer
+ */
+interface CausalEventBufferOptions {
+    /**
+     * Maximum time (ms) to wait for causal predecessors before releasing anyway.
+     * Default: 5000ms. Set to 0 or Infinity to wait indefinitely.
+     */
+    maxWaitTime?: number;
+    /**
+     * Maximum number of events to buffer before force-releasing oldest.
+     * Default: 1000. Prevents unbounded memory growth.
+     */
+    maxBufferSize?: number;
+    /**
+     * Callback when an event is released despite missing predecessors (timeout or buffer overflow).
+     */
+    onForcedRelease?: (event: CausalEvent, missingPredecessors: string[]) => void;
+}
+/**
+ * Result from pushing an event to the buffer
+ */
+interface CausalBufferPushResult {
+    /** Events that are now ready to be processed in causal order */
+    ready: CausalEvent[];
+    /** Number of events still waiting for predecessors */
+    pending: number;
+}
+/**
+ * Buffers events and releases them in causal order.
+ *
+ * Events with `causedBy` dependencies are held until all predecessor events
+ * have been seen (pushed to the buffer). Events without dependencies are
+ * released immediately.
+ *
+ * @example
+ * ```typescript
+ * const buffer = new CausalEventBuffer();
+ *
+ * // Event B depends on A, but arrives first
+ * let result = buffer.push({
+ *   eventId: 'B',
+ *   causedBy: ['A'],
+ *   event: { id: 'B', type: 'effect', timestamp: 2 }
+ * });
+ * console.log(result.ready);   // [] - B is waiting for A
+ * console.log(result.pending); // 1
+ *
+ * // Event A arrives
+ * result = buffer.push({
+ *   eventId: 'A',
+ *   event: { id: 'A', type: 'cause', timestamp: 1 }
+ * });
+ * console.log(result.ready);   // [A, B] - Both released in order
+ * console.log(result.pending); // 0
+ * ```
+ */
+declare class CausalEventBuffer {
+    #private;
+    constructor(options?: CausalEventBufferOptions);
+    /**
+     * Push an event into the buffer.
+     *
+     * @param event - The event to buffer
+     * @returns Events that are ready to be processed (in causal order)
+     */
+    push(event: CausalEvent): CausalBufferPushResult;
+    /**
+     * Get the number of events waiting for predecessors
+     */
+    get pendingCount(): number;
+    /**
+     * Get the number of unique events seen
+     */
+    get seenCount(): number;
+    /**
+     * Check if a specific event has been seen
+     */
+    hasSeen(eventId: string): boolean;
+    /**
+     * Force release all pending events, regardless of missing predecessors.
+     * Useful for cleanup or when you know no more events are coming.
+     *
+     * @returns All pending events in the order they would be released
+     */
+    flush(): CausalEvent[];
+    /**
+     * Clear all state (seen events, pending events)
+     */
+    clear(): void;
+}
+/**
+ * Validate that events are in causal order.
+ *
+ * An event sequence is in causal order if no event appears before
+ * any of its predecessors (events in its causedBy array).
+ *
+ * @param events - Events to validate
+ * @returns True if events are in valid causal order
+ *
+ * @example
+ * ```typescript
+ * const events = [
+ *   { eventId: 'A', event: {...} },
+ *   { eventId: 'B', causedBy: ['A'], event: {...} },
+ *   { eventId: 'C', causedBy: ['B'], event: {...} },
+ * ];
+ * console.log(validateCausalOrder(events)); // true
+ *
+ * const badOrder = [
+ *   { eventId: 'B', causedBy: ['A'], event: {...} },
+ *   { eventId: 'A', event: {...} },  // A should come before B
+ * ];
+ * console.log(validateCausalOrder(badOrder)); // false
+ * ```
+ */
+declare function validateCausalOrder(events: CausalEvent[]): boolean;
+/**
+ * Sort events into causal order using topological sort.
+ *
+ * If the events form a valid DAG (no cycles), returns them in an order
+ * where no event appears before its predecessors. If there are cycles
+ * or missing predecessors, throws an error.
+ *
+ * @param events - Events to sort
+ * @returns Events in causal order
+ * @throws If events contain cycles or reference missing predecessors
+ *
+ * @example
+ * ```typescript
+ * const unordered = [
+ *   { eventId: 'C', causedBy: ['B'], event: {...} },
+ *   { eventId: 'A', event: {...} },
+ *   { eventId: 'B', causedBy: ['A'], event: {...} },
+ * ];
+ * const ordered = sortCausalOrder(unordered);
+ * // ordered = [A, B, C]
+ * ```
+ */
+declare function sortCausalOrder(events: CausalEvent[]): CausalEvent[];
+
+/**
+ * Federation Envelope Utilities
+ *
+ * Provides functions for creating and processing federation envelopes
+ * for routing messages between federated MAP systems.
+ */
+
+/**
+ * Options for creating a federation envelope.
+ */
+interface CreateEnvelopeOptions {
+    /** Correlation ID for cross-system tracing */
+    correlationId?: string;
+    /** Maximum number of hops before rejection */
+    maxHops?: number;
+    /** Whether to track the full routing path */
+    trackPath?: boolean;
+}
+/**
+ * Result of processing a federation envelope.
+ */
+type ProcessEnvelopeResult<T> = {
+    success: true;
+    envelope: FederationEnvelope<T>;
+} | {
+    success: false;
+    errorCode: number;
+    errorMessage: string;
+};
+/**
+ * Create a new federation envelope for outbound messages.
+ *
+ * @param payload - The payload to wrap (typically a Message)
+ * @param sourceSystem - ID of the originating system
+ * @param targetSystem - ID of the destination system
+ * @param options - Optional envelope options
+ * @returns A new federation envelope
+ *
+ * @example
+ * ```typescript
+ * const envelope = createFederationEnvelope(
+ *   message,
+ *   'system-alpha',
+ *   'system-beta',
+ *   { trackPath: true, correlationId: 'req-123' }
+ * );
+ * ```
+ */
+declare function createFederationEnvelope<T>(payload: T, sourceSystem: string, targetSystem: string, options?: CreateEnvelopeOptions): FederationEnvelope<T>;
+/**
+ * Process an incoming federation envelope for forwarding.
+ *
+ * Validates the envelope against routing configuration and returns
+ * an updated envelope ready for forwarding, or an error if routing
+ * should be rejected.
+ *
+ * Checks performed:
+ * 1. Hop count hasn't exceeded maximum
+ * 2. No routing loops (if path tracking enabled)
+ * 3. Source system is in allowed sources (if configured)
+ * 4. Target system is in allowed targets (if configured)
+ *
+ * @param envelope - The incoming envelope
+ * @param config - Routing configuration for this system
+ * @returns Updated envelope or error result
+ *
+ * @example
+ * ```typescript
+ * const result = processFederationEnvelope(envelope, {
+ *   systemId: 'system-gamma',
+ *   maxHops: 5,
+ *   trackPath: true,
+ * });
+ *
+ * if (result.success) {
+ *   forwardToNext(result.envelope);
+ * } else {
+ *   rejectWithError(result.errorCode, result.errorMessage);
+ * }
+ * ```
+ */
+declare function processFederationEnvelope<T>(envelope: FederationEnvelope<T>, config: FederationRoutingConfig): ProcessEnvelopeResult<T>;
+/**
+ * Check if an envelope has reached its final destination.
+ *
+ * @param envelope - The envelope to check
+ * @param currentSystemId - ID of the current system
+ * @returns true if this is the target system
+ */
+declare function isEnvelopeAtDestination(envelope: FederationEnvelope<unknown>, currentSystemId: string): boolean;
+/**
+ * Extract the payload from a federation envelope.
+ *
+ * @param envelope - The envelope to unwrap
+ * @returns The payload
+ */
+declare function unwrapEnvelope<T>(envelope: FederationEnvelope<T>): T;
+/**
+ * Get routing metadata for logging/debugging.
+ *
+ * @param envelope - The envelope to inspect
+ * @returns Routing information
+ */
+declare function getEnvelopeRoutingInfo(envelope: FederationEnvelope<unknown>): {
+    source: string;
+    target: string;
+    hops: number;
+    path?: string[];
+    age: number;
+    correlationId?: string;
+};
+/**
+ * Validate that an object is a valid federation envelope.
+ *
+ * @param obj - Object to validate
+ * @returns true if valid envelope structure
+ */
+declare function isValidEnvelope(obj: unknown): obj is FederationEnvelope<unknown>;
+/**
+ * Create an updated envelope with a new payload (for transformations).
+ *
+ * @param envelope - Original envelope
+ * @param newPayload - New payload
+ * @returns New envelope with same metadata but new payload
+ */
+declare function withPayload<T, U>(envelope: FederationEnvelope<T>, newPayload: U): FederationEnvelope<U>;
+
+export { Address, AddressSchema, type AddressValidated, Agent, type AgentExposure, AgentId, AgentIdSchema, type AgentIdValidated, AgentLifecycleSchema, AgentRelationshipSchema, AgentSchema, AgentStateSchema, type AgentStateValidated, type AgentValidated, AgentVisibilitySchema, AgentsGetResponseResult, AgentsListResponseResult, AgentsRegisterResponseResult, AgentsSpawnResponseResult, AgentsUnregisterResponseResult, AgentsUpdateResponseResult, BaseConnectionOptions, BroadcastAddressSchema, type CapabilityPath, type CausalBufferPushResult, type CausalEvent, CausalEventBuffer, type CausalEventBufferOptions, ConnectResponseResult, type ConnectedParticipant, ConnectionState, CorrelationIdSchema, type CreateEnvelopeOptions, DEFAULT_RETRY_POLICY, DeliverySemanticsSchema, DirectAddressSchema, DisconnectResponseResult, ErrorCategory, ErrorCategorySchema, Event, type EventExposure, EventSchema, EventType, EventTypeSchema, type EventValidated, FederatedAddressSchema, FederationBufferConfig, FederationConnectResponseResult, FederationEnvelope, FederationOutageBuffer, FederationRouteResponseResult, FederationRoutingConfig, GatewayConnection, type GatewayConnectionOptions, HierarchicalAddressSchema, JsonRpcVersionSchema, MAPConnectionError, MAPError, MAPErrorData, MAPErrorDataSchema, MAPErrorSchema, type MAPErrorValidated, MAPNotificationSchema, type MAPNotificationValidated, MAPRequestError, MAPRequestSchema, type MAPRequestValidated, MAPResponseErrorSchema, MAPResponseSchema, MAPResponseSuccessSchema, type MAPResponseValidated, type MAPRouter, type MAPRouterConfig, type MAPRouterFactory, MAPTimeoutError, METHOD_REGISTRY, Message, MessageId, MessageIdSchema, type MessageIdValidated, MessageMetaSchema, MessagePrioritySchema, MessageRelationshipSchema, MessageSchema, type MessageValidated, MessageVisibilitySchema, MetaSchema, type MethodCategory, type MethodInfo, MultiAddressSchema, ParticipantAddressSchema, ParticipantCapabilities, ParticipantCapabilitiesSchema, type ParticipantCapabilitiesValidated, ParticipantId, ParticipantIdSchema, type ParticipantIdValidated, ParticipantType, ParticipantTypeSchema, type ParticipantTypeValidated, type PeerBufferStats, type ProcessEnvelopeResult, ProtocolVersion, ProtocolVersionSchema, RequestId, RequestIdSchema, type RetryCallbacks, type RetryPolicy, type RetryState, RoleAddressSchema, type RouterLimits, Scope, ScopeAddressSchema, type ScopeExposure, ScopeId, ScopeIdSchema, type ScopeIdValidated, ScopeJoinPolicySchema, ScopeSchema, ScopeSendPolicySchema, type ScopeValidated, ScopeVisibilitySchema, ScopesCreateResponseResult, ScopesJoinResponseResult, ScopesLeaveResponseResult, ScopesListResponseResult, SendResponseResult, SessionId, SessionIdSchema, type SessionIdValidated, SessionInfo, Stream, SubscribeResponseResult, SubscriptionFilter, SubscriptionFilterSchema, type SubscriptionFilterValidated, SubscriptionId, SubscriptionIdSchema, SystemAddressSchema, type SystemExposure, TimestampSchema, TransportTypeSchema, UnsubscribeResponseResult, buildAgentsGetResponse, buildAgentsListResponse, buildAgentsRegisterResponse, buildAgentsSpawnResponse, buildAgentsUnregisterResponse, buildAgentsUpdateResponse, buildConnectResponse, buildDisconnectResponse, buildScopesCreateResponse, buildScopesJoinResponse, buildScopesLeaveResponse, buildScopesListResponse, buildSendResponse, buildSubscribeResponse, buildUnsubscribeResponse, calculateDelay, compareUlid, createErrorResponse, createFederationEnvelope, createNotification, createRequest, createRetryPolicy, createSuccessResponse, getEnvelopeRoutingInfo, getMethodInfo, getMethodsByCategory, getRequiredCapabilities, hasRequiredCapabilities, isEnvelopeAtDestination, isErrorResponse, isNotification, isRequest, isResponse, isValidEnvelope, isValidUlid, processFederationEnvelope, retryable, sleep, sortCausalOrder, ulidTimestamp, unwrapEnvelope, validateCausalOrder, withPayload, withRetry };