@highway1/core 0.1.47 → 0.1.51

package/dist/index.d.ts

@@ -1,5 +1,3 @@
-import { Libp2p } from 'libp2p';
-import { PrivateKey } from '@libp2p/interface';
 import { Level } from 'level';
 
 interface KeyPair {
@@ -61,32 +59,6 @@ declare function signMessage(payload: Uint8Array, privateKey: Uint8Array, public
  */
 declare function verifyMessage(signedMessage: SignedMessage, expectedPublicKey: Uint8Array): Promise<boolean>;
 
-interface TransportConfig {
-    keyPair?: KeyPair;
-    listenAddresses?: string[];
-    bootstrapPeers?: string[];
-    enableDHT?: boolean;
-    /** Run as a relay server so NAT'd agents can receive messages through this node */
-    enableRelay?: boolean;
-    /** Reserve a relay slot on bootstrap nodes so others can reach us (only needed for hw1 join) */
-    reserveRelaySlot?: boolean;
-    /** Enable mDNS local peer discovery (default: false) */
-    enableMDNS?: boolean;
-    /** libp2p PrivateKey for persistent PeerID (from @libp2p/crypto) */
-    privateKey?: PrivateKey;
-}
-interface ClawiverseNode {
-    libp2p: Libp2p;
-    start: () => Promise<void>;
-    stop: () => Promise<void>;
-    getMultiaddrs: () => string[];
-    getPeerId: () => string;
-}
-/**
- * Create a Clawiverse transport node with libp2p
- */
-declare function createNode(config: TransportConfig): Promise<ClawiverseNode>;
-
 /**
  * Trust Score System
  *
@@ -224,6 +196,167 @@ declare function upgradeLegacyCard(legacy: LegacyAgentCard): AgentCard;
  */
 declare function downgradeToLegacyCard(card: AgentCard): LegacyAgentCard;
 
+/**
+ * CVP-0011: Relay wire protocol types (shared between relay server and relay client)
+ */
+
+declare const RELAY_PROTOCOL_VERSION = 1;
+type RelayMessageType = 'HELLO' | 'WELCOME' | 'SEND' | 'DELIVER' | 'DISCOVER' | 'DISCOVERED' | 'PING' | 'PONG' | 'ACK' | 'DELIVERY_REPORT' | 'FETCH_CARD' | 'CARD' | 'GOODBYE' | 'INDEX_SYNC' | 'ROUTE' | 'SYNC_HELLO' | 'SYNC_REQUEST' | 'SYNC_RESPONSE' | 'SYNC_PUSH' | 'SYNC_RECONCILE';
+interface HelloMessage {
+    type: 'HELLO';
+    protocolVersion: number;
+    did: string;
+    card: AgentCard;
+    timestamp: number;
+    signature: Uint8Array;
+    extensions?: string[];
+}
+interface WelcomeMessage {
+    type: 'WELCOME';
+    protocolVersion: number;
+    relayId: string;
+    peers: number;
+    federatedRelays: string[];
+    yourAddr: string;
+}
+interface SendMessage {
+    type: 'SEND';
+    to: string;
+    envelope: Uint8Array;
+}
+interface DeliverMessage {
+    type: 'DELIVER';
+    messageId: string;
+    from: string;
+    envelope: Uint8Array;
+}
+interface DiscoverMessage {
+    type: 'DISCOVER';
+    query: string;
+    minTrust?: number;
+    limit?: number;
+}
+interface DiscoveredAgent {
+    did: string;
+    card: AgentCard;
+    online: boolean;
+    homeRelay?: string;
+}
+interface DiscoveredMessage {
+    type: 'DISCOVERED';
+    agents: DiscoveredAgent[];
+}
+interface AckMessage {
+    type: 'ACK';
+    messageId: string;
+}
+interface DeliveryReportMessage {
+    type: 'DELIVERY_REPORT';
+    messageId: string;
+    status: 'delivered' | 'expired' | 'queue_full' | 'unknown_recipient';
+    timestamp: number;
+}
+interface PingMessage {
+    type: 'PING';
+}
+interface PongMessage {
+    type: 'PONG';
+    peers: number;
+}
+interface FetchCardMessage {
+    type: 'FETCH_CARD';
+    did: string;
+}
+interface CardMessage {
+    type: 'CARD';
+    did: string;
+    card: AgentCard | null;
+}
+interface GoodbyeMessage {
+    type: 'GOODBYE';
+}
+interface PresenceProof {
+    did: string;
+    homeRelay: string;
+    expiry: number;
+    signature: Uint8Array;
+}
+interface SyncEvent {
+    seq: number;
+    type: 'JOIN' | 'LEAVE' | 'UPDATE';
+    did: string;
+    homeRelay: string;
+    cardHash?: string;
+    capabilityKeys?: string[];
+    online: boolean;
+    ts: number;
+    presenceProof?: PresenceProof;
+}
+interface IndexSyncMessage {
+    type: 'INDEX_SYNC';
+    events: SyncEvent[];
+}
+interface RouteMessage {
+    type: 'ROUTE';
+    to: string;
+    envelope: Uint8Array;
+    ttl: number;
+}
+interface SyncHelloMessage {
+    type: 'SYNC_HELLO';
+    relayId: string;
+    seq: number;
+}
+interface SyncRequestMessage {
+    type: 'SYNC_REQUEST';
+    fromSeq: number;
+}
+interface SyncResponseMessage {
+    type: 'SYNC_RESPONSE';
+    events: SyncEvent[];
+}
+interface SyncPushMessage {
+    type: 'SYNC_PUSH';
+    event: SyncEvent;
+}
+interface SyncReconcileMessage {
+    type: 'SYNC_RECONCILE';
+    dids: string[];
+}
+type RelayMessage = HelloMessage | WelcomeMessage | SendMessage | DeliverMessage | DiscoverMessage | DiscoveredMessage | AckMessage | DeliveryReportMessage | PingMessage | PongMessage | FetchCardMessage | CardMessage | GoodbyeMessage | IndexSyncMessage | RouteMessage | SyncHelloMessage | SyncRequestMessage | SyncResponseMessage | SyncPushMessage | SyncReconcileMessage;
+
+/**
+ * CVP-0011: WebSocket relay client with reconnection logic
+ */
+
+interface RelayClientConfig {
+    relayUrls: string[];
+    did: string;
+    keyPair: KeyPair;
+    card: AgentCard;
+    reconnect?: {
+        baseMs?: number;
+        jitterMs?: number;
+        maxDelayMs?: number;
+        stableAfterMs?: number;
+    };
+}
+type MessageDeliveryHandler = (msg: DeliverMessage) => Promise<void>;
+type DeliveryReportHandler = (msg: DeliveryReportMessage) => void;
+interface RelayClient {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    sendEnvelope(toDid: string, envelopeBytes: Uint8Array): Promise<void>;
+    discover(query: string, minTrust?: number, limit?: number): Promise<DiscoveredAgent[]>;
+    fetchCard(did: string): Promise<AgentCard | null>;
+    onDeliver(handler: MessageDeliveryHandler): void;
+    onDeliveryReport(handler: DeliveryReportHandler): void;
+    isConnected(): boolean;
+    getConnectedRelays(): string[];
+    getPeerCount(): number;
+}
+declare function createRelayClient(config: RelayClientConfig): RelayClient;
+
 /**
  * Create a new Agent Card (Phase 2 format with structured capabilities)
  */
@@ -441,22 +574,25 @@ declare class SearchIndex {
     private applyFilters;
 }
 
-interface ResolvedDID {
-    peerId: string;
-    multiaddrs: string[];
-}
-interface DHTOperations {
+/**
+ * CVP-0011: Relay-backed discovery operations
+ * Implements the same DHTOperations interface shape but backed by relay queries
+ */
+
+interface RelayIndexOperations {
     publishAgentCard: (card: AgentCard) => Promise<void>;
     queryAgentCard: (did: string) => Promise<AgentCard | null>;
     queryByCapability: (capability: string) => Promise<AgentCard[]>;
     searchSemantic: (query: SemanticQuery) => Promise<AgentCard[]>;
-    resolveDID: (did: string) => Promise<ResolvedDID | null>;
+    resolveDID: (did: string) => Promise<{
+        relayUrl: string;
+    } | null>;
     queryRelayPeers: () => Promise<string[]>;
 }
 /**
- * Create DHT operations for a libp2p node
+ * Create relay-backed discovery operations
  */
-declare function createDHTOperations(libp2p: Libp2p): DHTOperations;
+declare function createRelayIndexOperations(client: RelayClient): RelayIndexOperations;
 
 /**
  * Capability Matcher
@@ -495,6 +631,19 @@ declare class CapabilityMatcher {
     private levenshteinDistance;
 }
 
+interface ResolvedDID {
+    peerId: string;
+    multiaddrs: string[];
+}
+interface DHTOperations {
+    publishAgentCard: (card: AgentCard) => Promise<void>;
+    queryAgentCard: (did: string) => Promise<AgentCard | null>;
+    queryByCapability: (capability: string) => Promise<AgentCard[]>;
+    searchSemantic: (query: SemanticQuery) => Promise<AgentCard[]>;
+    resolveDID: (did: string) => Promise<ResolvedDID | null>;
+    queryRelayPeers: () => Promise<string[]>;
+}
+
 /**
  * Semantic Search Engine
  *
@@ -603,24 +752,229 @@ declare function encodeMessageJSON(envelope: MessageEnvelope): string;
 declare function decodeMessageJSON(json: string): MessageEnvelope;
 
 type MessageHandler = (envelope: MessageEnvelope) => Promise<MessageEnvelope | void>;
-interface PeerHint {
-    peerId: string;
-    multiaddrs: string[];
-}
 interface MessageRouter {
     registerHandler: (protocol: string, handler: MessageHandler) => void;
     unregisterHandler: (protocol: string) => void;
     registerCatchAllHandler: (handler: MessageHandler) => void;
-    sendMessage: (envelope: MessageEnvelope, peerHint?: PeerHint) => Promise<MessageEnvelope | void>;
+    sendMessage: (envelope: MessageEnvelope) => Promise<MessageEnvelope | void>;
     start: () => Promise<void>;
     stop: () => Promise<void>;
 }
 /**
- * Create a message router for a libp2p node.
- * When dht is provided, sendMessage can resolve DIDs to peer addresses via DHT lookup.
- * When relayPeers is provided, sendMessage will attempt relay fallback if direct dial fails.
+ * Create a message router using relay client (CVP-0011)
  */
-declare function createMessageRouter(libp2p: Libp2p, verifyFn: (signature: Uint8Array, data: Uint8Array) => Promise<boolean>, dht?: DHTOperations, relayPeers?: string[]): MessageRouter;
+declare function createMessageRouter(relayClient: RelayClient, verifyFn: (signature: Uint8Array, data: Uint8Array) => Promise<boolean>): MessageRouter;
+
+/**
+ * Message Queue Types
+ *
+ * Types for message queue, storage, and filtering operations.
+ */
+
+/**
+ * Message direction
+ */
+type MessageDirection = 'inbound' | 'outbound';
+/**
+ * Message status
+ */
+type MessageStatus = 'pending' | 'delivered' | 'failed' | 'archived';
+/**
+ * Stored message with metadata
+ */
+interface StoredMessage {
+    envelope: MessageEnvelope;
+    direction: MessageDirection;
+    status: MessageStatus;
+    receivedAt?: number;
+    sentAt?: number;
+    readAt?: number;
+    trustScore?: number;
+    error?: string;
+}
+/**
+ * Message filter for queries
+ */
+interface MessageFilter {
+    fromDid?: string | string[];
+    toDid?: string | string[];
+    protocol?: string | string[];
+    minTrustScore?: number;
+    maxAge?: number;
+    type?: 'request' | 'response' | 'notification';
+    unreadOnly?: boolean;
+    status?: MessageStatus | MessageStatus[];
+}
+/**
+ * Pagination options
+ */
+interface PaginationOptions {
+    limit?: number;
+    offset?: number;
+    startKey?: string;
+}
+/**
+ * Paginated message results
+ */
+interface MessagePage {
+    messages: StoredMessage[];
+    total: number;
+    hasMore: boolean;
+    nextKey?: string;
+}
+/**
+ * Blocklist entry
+ */
+interface BlocklistEntry {
+    did: string;
+    reason: string;
+    blockedAt: number;
+    blockedBy: string;
+}
+/**
+ * Allowlist entry
+ */
+interface AllowlistEntry {
+    did: string;
+    addedAt: number;
+    note?: string;
+}
+/**
+ * Seen cache entry (for deduplication)
+ */
+interface SeenEntry {
+    messageId: string;
+    seenAt: number;
+    fromDid: string;
+}
+/**
+ * Rate limit state
+ */
+interface RateLimitState {
+    did: string;
+    tokens: number;
+    lastRefill: number;
+    totalRequests: number;
+    firstSeen: number;
+}
+/**
+ * Defense check result
+ */
+interface DefenseResult {
+    allowed: boolean;
+    reason?: 'blocked' | 'duplicate' | 'trust_too_low' | 'rate_limited' | 'invalid';
+    trustScore?: number;
+    remainingTokens?: number;
+    resetTime?: number;
+}
+/**
+ * Rate limit result
+ */
+interface RateLimitResult {
+    allowed: boolean;
+    remaining: number;
+    resetTime: number;
+    limit: number;
+}
+/**
+ * Queue statistics
+ */
+interface QueueStats {
+    inboxTotal: number;
+    inboxUnread: number;
+    outboxPending: number;
+    outboxFailed: number;
+    blockedAgents: number;
+    allowedAgents: number;
+    rateLimitedAgents: number;
+}
+/**
+ * Subscription callback
+ */
+type MessageCallback = (message: StoredMessage) => void | Promise<void>;
+/**
+ * Subscription filter
+ */
+interface SubscriptionFilter extends MessageFilter {
+    webhookUrl?: string;
+}
+
+/**
+ * Message Storage - LevelDB operations for message queue
+ *
+ * Key schema:
+ *   msg:inbound:{timestamp}:{id}   → StoredMessage
+ *   msg:outbound:{timestamp}:{id}  → StoredMessage
+ *   block:{did}                    → BlocklistEntry
+ *   allow:{did}                    → AllowlistEntry
+ *   seen:{messageId}               → SeenEntry
+ *   rate:{did}                     → RateLimitState
+ *   idx:from:{did}:{timestamp}:{id} → '1'
+ */
+
+declare class MessageStorage {
+    private db;
+    private ready;
+    constructor(dbPath: string);
+    open(): Promise<void>;
+    close(): Promise<void>;
+    putMessage(msg: StoredMessage): Promise<void>;
+    getMessage(id: string): Promise<StoredMessage | null>;
+    updateMessage(id: string, updates: Partial<StoredMessage>): Promise<void>;
+    deleteMessage(id: string): Promise<void>;
+    queryMessages(direction: 'inbound' | 'outbound', filter?: MessageFilter, pagination?: PaginationOptions): Promise<MessagePage>;
+    private matchesFilter;
+    countMessages(direction: 'inbound' | 'outbound', filter?: MessageFilter): Promise<number>;
+    putBlock(entry: BlocklistEntry): Promise<void>;
+    getBlock(did: string): Promise<BlocklistEntry | null>;
+    deleteBlock(did: string): Promise<void>;
+    listBlocked(): Promise<BlocklistEntry[]>;
+    putAllow(entry: AllowlistEntry): Promise<void>;
+    getAllow(did: string): Promise<AllowlistEntry | null>;
+    deleteAllow(did: string): Promise<void>;
+    listAllowed(): Promise<AllowlistEntry[]>;
+    putSeen(entry: SeenEntry): Promise<void>;
+    getSeen(messageId: string): Promise<SeenEntry | null>;
+    cleanupSeen(maxAgeMs: number): Promise<void>;
+    putRateLimit(state: RateLimitState): Promise<void>;
+    getRateLimit(did: string): Promise<RateLimitState | null>;
+    cleanupRateLimits(maxAgeMs: number): Promise<void>;
+}
+
+/**
+ * Message Queue
+ *
+ * Persistent inbox/outbox backed by LevelDB.
+ * Supports real-time subscriptions and pagination.
+ */
+
+interface MessageQueueConfig {
+    dbPath: string;
+}
+declare class MessageQueue {
+    private storage;
+    private subscriptions;
+    private subCounter;
+    constructor(config: MessageQueueConfig);
+    get store(): MessageStorage;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getInbox(filter?: MessageFilter, pagination?: PaginationOptions): Promise<MessagePage>;
+    getMessage(id: string): Promise<StoredMessage | null>;
+    markAsRead(id: string): Promise<void>;
+    deleteMessage(id: string): Promise<void>;
+    getOutbox(pagination?: PaginationOptions): Promise<MessagePage>;
+    retryMessage(id: string): Promise<void>;
+    enqueueInbound(envelope: MessageEnvelope, trustScore?: number): Promise<StoredMessage>;
+    enqueueOutbound(envelope: MessageEnvelope): Promise<StoredMessage>;
+    markOutboundDelivered(id: string): Promise<void>;
+    markOutboundFailed(id: string, error: string): Promise<void>;
+    subscribe(filter: SubscriptionFilter, callback: MessageCallback): string;
+    unsubscribe(subscriptionId: string): void;
+    private notifySubscribers;
+    private matchesSubscriptionFilter;
+    getStats(): Promise<QueueStats>;
+}
 
 /**
  * Sybil Defense Mechanisms
@@ -886,6 +1240,102 @@ declare class TrustSystem {
  */
 declare function createTrustSystem(config: TrustSystemConfig): TrustSystem;
 
+/**
+ * Token Bucket Rate Limiter
+ *
+ * Classic token bucket algorithm for per-sender rate limiting.
+ * Tokens refill at a constant rate up to capacity.
+ */
+interface TokenBucketConfig {
+    capacity: number;
+    refillRate: number;
+}
+declare class TokenBucket {
+    private tokens;
+    private lastRefill;
+    private readonly capacity;
+    private readonly refillRate;
+    constructor(config: TokenBucketConfig, initialTokens?: number, lastRefill?: number);
+    /** Attempt to consume one token. Returns true if allowed. */
+    consume(): boolean;
+    getRemaining(): number;
+    /** Milliseconds until at least one token is available */
+    getResetTime(): number;
+    /** Serialize state for persistence */
+    toState(): {
+        tokens: number;
+        lastRefill: number;
+    };
+    private refill;
+}
+/**
+ * Rate limiter tiers based on trust score
+ */
+interface RateLimitTiers {
+    /** Trust < 0.3: new/unknown agents */
+    newAgent: TokenBucketConfig;
+    /** Trust 0.3–0.6: established agents */
+    established: TokenBucketConfig;
+    /** Trust > 0.6: trusted agents */
+    trusted: TokenBucketConfig;
+}
+declare const DEFAULT_RATE_LIMIT_TIERS: RateLimitTiers;
+declare function getTierConfig(trustScore: number, tiers: RateLimitTiers): TokenBucketConfig;
+
+/**
+ * Defense Middleware
+ *
+ * Checks incoming messages against:
+ * 1. Allowlist bypass
+ * 2. Blocklist rejection
+ * 3. Deduplication (seen cache)
+ * 4. Trust score filtering
+ * 5. Rate limiting (token bucket, tiered by trust)
+ */
+
+interface DefenseConfig {
+    trustSystem: TrustSystem;
+    storage: MessageStorage;
+    /** Minimum trust score to accept messages (0 = accept all) */
+    minTrustScore?: number;
+    /** Auto-block agents below this score */
+    autoBlockThreshold?: number;
+    rateLimitTiers?: RateLimitTiers;
+    /** TTL for seen-cache entries in ms (default: 1 hour) */
+    seenTtlMs?: number;
+}
+declare class DefenseMiddleware {
+    private readonly trust;
+    private readonly storage;
+    private readonly minTrustScore;
+    private readonly autoBlockThreshold;
+    private readonly tiers;
+    private readonly seenTtlMs;
+    private readonly seenCache;
+    private readonly MAX_SEEN_CACHE;
+    private readonly buckets;
+    constructor(config: DefenseConfig);
+    /**
+     * Run all defense checks on an incoming message.
+     * Returns { allowed: true } if the message should be processed,
+     * or { allowed: false, reason } if it should be dropped.
+     */
+    checkMessage(envelope: MessageEnvelope): Promise<DefenseResult>;
+    blockAgent(did: string, reason: string, blockedBy?: string): Promise<void>;
+    unblockAgent(did: string): Promise<void>;
+    isBlocked(did: string): Promise<boolean>;
+    allowAgent(did: string, note?: string): Promise<void>;
+    removeFromAllowlist(did: string): Promise<void>;
+    isAllowed(did: string): Promise<boolean>;
+    checkRateLimit(did: string, trustScore: number): Promise<RateLimitResult>;
+    hasSeen(messageId: string): boolean;
+    markAsSeen(messageId: string): void;
+    /** Periodic cleanup of expired seen entries */
+    cleanupSeen(): Promise<void>;
+    /** Periodic cleanup of stale rate limit buckets (24h inactive) */
+    cleanupRateLimits(): Promise<void>;
+}
+
 declare enum LogLevel {
     DEBUG = 0,
     INFO = 1,
@@ -922,4 +1372,4 @@ declare class MessagingError extends ClawiverseError {
     constructor(message: string, details?: unknown);
 }
 
-export { type AgentCard, CLAWIVERSE_CONTEXT, type Capability, CapabilityMatcher, type CapabilityParameter, CapabilityTypes, type Challenge, type ChallengeSolution, ClawiverseError, type ClawiverseNode, type DHTOperations, DiscoveryError, type Endorsement, EndorsementManager, IdentityError, type Interaction, InteractionHistory, type InteractionStats, type KeyPair, type LegacyAgentCard, LogLevel, Logger, type MessageEnvelope, type MessageHandler, type MessageRouter, MessagingError, ParameterTypes, type PeerHint, type PeerTrustLevel, type ResolvedDID, SCHEMA_ORG_CONTEXT, SearchIndex, type SearchResult, type SemanticQuery, SemanticSearchEngine, type SignFunction, type SignedMessage, SybilDefense, type TransportConfig, TransportError, TrustMetrics, type TrustScore, TrustSystem, type TrustSystemConfig, type VerifyFunction, clawiverseContext, createAgentCard, createDHTOperations, createDefaultTrustScore, createEnvelope, createLegacyAgentCard, createLogger, createMessageRouter, createNode, createSemanticSearch, createTrustSystem, decodeAgentCard, decodeFromCBOR, decodeFromJSON, decodeMessage, decodeMessageJSON, deriveDID, downgradeToLegacyCard, encodeForDHT, encodeForWeb, encodeMessage, encodeMessageJSON, exportKeyPair, extractPublicKey, generateKeyPair, getAgentCardContext, getEncodedSize, importKeyPair, isLegacyCard, isValidContext, matchesCapability, sign, signAgentCard, signEnvelope, signMessage, upgradeLegacyCard, validateAgentCard, validateDID, validateEnvelope, verify, verifyAgentCard, verifyEnvelope, verifyMessage };
+export { type AckMessage, type AgentCard, type AllowlistEntry, type BlocklistEntry, CLAWIVERSE_CONTEXT, type Capability, CapabilityMatcher, type CapabilityParameter, CapabilityTypes, type CardMessage, type Challenge, type ChallengeSolution, ClawiverseError, DEFAULT_RATE_LIMIT_TIERS, type DefenseConfig, DefenseMiddleware, type DefenseResult, type DeliverMessage, type DeliveryReportHandler, type DeliveryReportMessage, type DiscoverMessage, type DiscoveredAgent, type DiscoveredMessage, DiscoveryError, type Endorsement, EndorsementManager, type FetchCardMessage, type GoodbyeMessage, type HelloMessage, IdentityError, type IndexSyncMessage, type Interaction, InteractionHistory, type InteractionStats, type KeyPair, type LegacyAgentCard, LogLevel, Logger, type MessageCallback, type MessageDeliveryHandler, type MessageDirection, type MessageEnvelope, type MessageFilter, type MessageHandler, type MessagePage, MessageQueue, type MessageQueueConfig, type MessageRouter, type MessageStatus, MessageStorage, MessagingError, type PaginationOptions, ParameterTypes, type PeerTrustLevel, type PingMessage, type PongMessage, type PresenceProof, type QueueStats, RELAY_PROTOCOL_VERSION, type RateLimitResult, type RateLimitState, type RateLimitTiers, type RelayClient, type RelayClientConfig, type RelayIndexOperations, type RelayMessage, type RelayMessageType, type RouteMessage, SCHEMA_ORG_CONTEXT, SearchIndex, type SearchResult, type SeenEntry, type SemanticQuery, SemanticSearchEngine, type SendMessage, type SignFunction, type SignedMessage, type StoredMessage, type SubscriptionFilter, SybilDefense, type SyncEvent, type SyncHelloMessage, type SyncPushMessage, type SyncReconcileMessage, type SyncRequestMessage, type SyncResponseMessage, TokenBucket, type TokenBucketConfig, TransportError, TrustMetrics, type TrustScore, TrustSystem, type TrustSystemConfig, type VerifyFunction, type WelcomeMessage, clawiverseContext, createAgentCard, createDefaultTrustScore, createEnvelope, createLegacyAgentCard, createLogger, createMessageRouter, createRelayClient, createRelayIndexOperations, createSemanticSearch, createTrustSystem, decodeAgentCard, decodeFromCBOR, decodeFromJSON, decodeMessage, decodeMessageJSON, deriveDID, downgradeToLegacyCard, encodeForDHT, encodeForWeb, encodeMessage, encodeMessageJSON, exportKeyPair, extractPublicKey, generateKeyPair, getAgentCardContext, getEncodedSize, getTierConfig, importKeyPair, isLegacyCard, isValidContext, matchesCapability, sign, signAgentCard, signEnvelope, signMessage, upgradeLegacyCard, validateAgentCard, validateDID, validateEnvelope, verify, verifyAgentCard, verifyEnvelope, verifyMessage };