memeloop 0.0.1 → 0.1.1

package/dist/syncCloudDevices-BEqwgrhD.d.ts

@@ -0,0 +1,49 @@
+import { l as DeviceNetworkService, L as LocalDeviceIdentity, g as DeviceCapabilities, T as TrustedDeviceRecord, D as Device, P as PairingSession, x as LocalPairingRequestOptions, y as MemeLoopProtocol, h as DeviceConnectionGrant, M as MemeLoopDuplexStream, S as SyncResult, C as CloudDeviceClient, w as DeviceTrustStore, c as CloudDeviceRecord } from './types-CdFVSntj.js';
+
+interface MemoryDeviceNetworkServiceOptions {
+    identity: LocalDeviceIdentity;
+    capabilities?: DeviceCapabilities;
+    trustedDevices?: TrustedDeviceRecord[];
+}
+declare class MemoryDeviceNetworkService implements DeviceNetworkService {
+    private readonly options;
+    private started;
+    private readonly capabilities;
+    private readonly trustedDevices;
+    private readonly pairingSessions;
+    private readonly listeners;
+    private readonly pairingListeners;
+    constructor(options: MemoryDeviceNetworkServiceOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getLocalDevice(): Promise<Device>;
+    listDevices(): Promise<Device[]>;
+    observeDevices(listener: (devices: Device[]) => void): () => void;
+    listPairingSessions(): Promise<PairingSession[]>;
+    observePairingSessions(listener: (sessions: PairingSession[]) => void): () => void;
+    requestLocalPairing(peerId: string, _options?: LocalPairingRequestOptions): Promise<PairingSession>;
+    acceptPairing(sessionId: string): Promise<void>;
+    rejectPairing(sessionId: string): Promise<void>;
+    removeTrustedDevice(peerId: string): Promise<void>;
+    openStream(peerId: string, _protocol: MemeLoopProtocol, _presentedGrant?: DeviceConnectionGrant): Promise<MemeLoopDuplexStream>;
+    sendRpc<T>(peerId: string, _method: string, _parameters: unknown, _presentedGrant?: DeviceConnectionGrant): Promise<T>;
+    syncWithDevice(peerId: string, _presentedGrant?: DeviceConnectionGrant): Promise<SyncResult>;
+    private confirmCode;
+    private emitDevices;
+    private emitPairingSessions;
+}
+
+/**
+ * Fetch visible cloud devices and merge them into the local trust store.
+ * - Cloud devices become trusted with trustMode = "cloud-account".
+ * - Already-trusted devices are updated (capabilities, lastSeen, multiaddrs).
+ * - Revoked cloud devices are NOT removed from local trust store here
+ *   (revocation should be handled via heartbeat/grant failure).
+ * - Returns the synced cloud device records for caller to emit as discovered devices.
+ */
+declare function syncCloudDevices(input: {
+    cloudClient: CloudDeviceClient;
+    trustStore: DeviceTrustStore;
+}): Promise<CloudDeviceRecord[]>;
+
+export { MemoryDeviceNetworkService as M, type MemoryDeviceNetworkServiceOptions as a, syncCloudDevices as s };

package/dist/syncCloudDevices-Ds_Kcgrv.d.cts

@@ -0,0 +1,49 @@
+import { l as DeviceNetworkService, L as LocalDeviceIdentity, g as DeviceCapabilities, T as TrustedDeviceRecord, D as Device, P as PairingSession, x as LocalPairingRequestOptions, y as MemeLoopProtocol, h as DeviceConnectionGrant, M as MemeLoopDuplexStream, S as SyncResult, C as CloudDeviceClient, w as DeviceTrustStore, c as CloudDeviceRecord } from './types-7pYti-k9.cjs';
+
+interface MemoryDeviceNetworkServiceOptions {
+    identity: LocalDeviceIdentity;
+    capabilities?: DeviceCapabilities;
+    trustedDevices?: TrustedDeviceRecord[];
+}
+declare class MemoryDeviceNetworkService implements DeviceNetworkService {
+    private readonly options;
+    private started;
+    private readonly capabilities;
+    private readonly trustedDevices;
+    private readonly pairingSessions;
+    private readonly listeners;
+    private readonly pairingListeners;
+    constructor(options: MemoryDeviceNetworkServiceOptions);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getLocalDevice(): Promise<Device>;
+    listDevices(): Promise<Device[]>;
+    observeDevices(listener: (devices: Device[]) => void): () => void;
+    listPairingSessions(): Promise<PairingSession[]>;
+    observePairingSessions(listener: (sessions: PairingSession[]) => void): () => void;
+    requestLocalPairing(peerId: string, _options?: LocalPairingRequestOptions): Promise<PairingSession>;
+    acceptPairing(sessionId: string): Promise<void>;
+    rejectPairing(sessionId: string): Promise<void>;
+    removeTrustedDevice(peerId: string): Promise<void>;
+    openStream(peerId: string, _protocol: MemeLoopProtocol, _presentedGrant?: DeviceConnectionGrant): Promise<MemeLoopDuplexStream>;
+    sendRpc<T>(peerId: string, _method: string, _parameters: unknown, _presentedGrant?: DeviceConnectionGrant): Promise<T>;
+    syncWithDevice(peerId: string, _presentedGrant?: DeviceConnectionGrant): Promise<SyncResult>;
+    private confirmCode;
+    private emitDevices;
+    private emitPairingSessions;
+}
+
+/**
+ * Fetch visible cloud devices and merge them into the local trust store.
+ * - Cloud devices become trusted with trustMode = "cloud-account".
+ * - Already-trusted devices are updated (capabilities, lastSeen, multiaddrs).
+ * - Revoked cloud devices are NOT removed from local trust store here
+ *   (revocation should be handled via heartbeat/grant failure).
+ * - Returns the synced cloud device records for caller to emit as discovered devices.
+ */
+declare function syncCloudDevices(input: {
+    cloudClient: CloudDeviceClient;
+    trustStore: DeviceTrustStore;
+}): Promise<CloudDeviceRecord[]>;
+
+export { MemoryDeviceNetworkService as M, type MemoryDeviceNetworkServiceOptions as a, syncCloudDevices as s };

package/dist/types-7pYti-k9.d.cts

@@ -0,0 +1,255 @@
+import { V as VersionVector, C as ConversationMeta, b as ChatMessage } from './interface-IrKBFtL1.cjs';
+
+type DevicePlatform = 'desktop' | 'mobile' | 'cli';
+type DeviceTrustMode = 'local-pairing' | 'cloud-account';
+type DeviceReachabilityState = 'nearby' | 'online' | 'offline' | 'connecting';
+type DeviceNetworkPath = 'lan' | 'direct' | 'relay';
+type DeviceProtocolDirection = 'inbound' | 'outbound';
+type PairingSessionDirection = 'inbound' | 'outbound';
+type PairingSessionStatus = 'pending' | 'accepted' | 'rejected' | 'expired';
+type MemeLoopProtocol = '/memeloop/rpc/1.0.0' | '/memeloop/sync/1.0.0' | '/memeloop/agent/1.0.0' | '/memeloop/pairing/1.0.0' | '/memeloop/orchestration/1.0.0';
+interface DeviceCapabilities {
+    tools: string[];
+    mcpServers: string[];
+    hasWiki: boolean;
+    agentLoop?: boolean;
+    imChannels: string[];
+    wikis: Array<{
+        wikiId: string;
+        title?: string;
+        pathHint?: string;
+    }>;
+}
+interface LocalDeviceIdentity {
+    peerId: string;
+    publicKeyMultibase: string;
+    privateKeyRef: string;
+    privateKeyPkcs8Base64Url?: string;
+    privateKeyRawSeedBase64Url?: string;
+    createdAt: number;
+    deviceName: string;
+    platform: DevicePlatform;
+}
+interface DeviceNetworkListenOptions {
+    addresses: string[];
+    announce?: string[];
+}
+interface DeviceReachability {
+    state: DeviceReachabilityState;
+    paths: DeviceNetworkPath[];
+}
+interface Device {
+    peerId: string;
+    displayName: string;
+    platform: DevicePlatform;
+    trustMode: DeviceTrustMode;
+    trusted?: boolean;
+    reachability: DeviceReachability;
+    capabilities: DeviceCapabilities;
+    multiaddrs?: string[];
+    lastSeen?: number;
+}
+interface TrustedDeviceRecord {
+    peerId: string;
+    publicKeyMultibase: string;
+    deviceName: string;
+    platform: DevicePlatform;
+    trustMode: DeviceTrustMode;
+    accountId?: string;
+    createdAt: number;
+    lastSeen?: number;
+    revokedAt?: number;
+}
+interface DeviceTrustStore {
+    loadTrustedDevices(): Promise<TrustedDeviceRecord[]>;
+    saveTrustedDevice(record: TrustedDeviceRecord): Promise<void>;
+    removeTrustedDevice(peerId: string): Promise<void>;
+}
+interface DeviceAccountBindingRequest {
+    peerId: string;
+    publicKeyMultibase: string;
+    deviceName: string;
+    platform: DevicePlatform;
+    cloudNonce: string;
+    signature: string;
+}
+interface CloudDeviceRecord {
+    accountId: string;
+    peerId: string;
+    publicKeyMultibase: string;
+    deviceName: string;
+    platform: DevicePlatform;
+    capabilities: DeviceCapabilities;
+    multiaddrs: string[];
+    relayReservations: string[];
+    lastSeen: number;
+    revokedAt?: number;
+}
+interface DeviceConnectionGrant {
+    issuer: 'memeloop-cloud';
+    accountId: string;
+    subjectPeerId: string;
+    allowedPeerIds: string[];
+    issuedAt: number;
+    expiresAt: number;
+    signature: string;
+}
+interface DeviceConnectionGrantVerificationInput {
+    grant: DeviceConnectionGrant;
+    verificationPublicKeyMultibase: string;
+    subjectPeerId?: string;
+    allowedPeerId?: string;
+    now?: number;
+}
+interface DeviceRelayReservationToken {
+    issuer: 'memeloop-cloud';
+    accountId: string;
+    peerId: string;
+    relayMultiaddrs: string[];
+    bootstrapMultiaddrs: string[];
+    issuedAt: number;
+    expiresAt: number;
+    signature: string;
+}
+interface DeviceRelayReservationTokenVerificationInput {
+    token: DeviceRelayReservationToken;
+    verificationPublicKeyMultibase: string;
+    peerId?: string;
+    now?: number;
+}
+interface PairingSession {
+    sessionId: string;
+    localPeerId: string;
+    remotePeerId: string;
+    remotePublicKeyMultibase: string;
+    remoteDeviceName: string;
+    remotePlatform: DevicePlatform;
+    remoteCapabilities: DeviceCapabilities;
+    remoteMultiaddrs: string[];
+    direction: PairingSessionDirection;
+    status: PairingSessionStatus;
+    confirmCode: string;
+    createdAt: number;
+    expiresAt: number;
+}
+interface LocalPairingRequestOptions {
+    multiaddrs?: string[];
+}
+interface SyncResult {
+    ok: boolean;
+    peerId: string;
+    syncedAt: number;
+}
+interface MemeLoopDuplexStream {
+    source: AsyncIterable<Uint8Array>;
+    sink(source: AsyncIterable<Uint8Array>): Promise<void>;
+    close(): Promise<void>;
+}
+interface DeviceRpcHandlerInput {
+    remotePeerId: string;
+    method: string;
+    parameters: unknown;
+    presentedGrant?: DeviceConnectionGrant;
+}
+type DeviceRpcHandler = (input: DeviceRpcHandlerInput) => Promise<unknown>;
+type AgentExecutionLocation = {
+    kind: 'local';
+} | {
+    kind: 'device';
+    peerId: string;
+};
+type AgentExecutionState = 'idle' | 'running' | 'stopping';
+interface ConversationExecutionPlacement {
+    conversationId: string;
+    location: AgentExecutionLocation;
+    state: AgentExecutionState;
+    updatedAt: number;
+}
+interface DeviceAuthorizer {
+    canOpenProtocol(input: {
+        remotePeerId: string;
+        protocol: MemeLoopProtocol;
+        direction?: DeviceProtocolDirection;
+        presentedGrant?: DeviceConnectionGrant;
+    }): Promise<boolean>;
+}
+interface CloudDeviceClient {
+    listDevices(): Promise<CloudDeviceRecord[]>;
+    getConnectionGrantPublicKey(): Promise<{
+        issuer: string;
+        publicKeyMultibase: string;
+    }>;
+    createConnectionGrant(input: {
+        subjectPeerId: string;
+        allowedPeerIds: string[];
+    }): Promise<DeviceConnectionGrant>;
+    createRelayReservation(input: {
+        peerId: string;
+    }): Promise<DeviceRelayReservationToken>;
+    createBindingNonce(): Promise<{
+        nonce: string;
+        accountId: string;
+        expiresAt: string;
+    }>;
+    registerDevice(input: DeviceAccountBindingRequest & {
+        identity: LocalDeviceIdentity;
+        capabilities: DeviceCapabilities;
+        multiaddrs: string[];
+        relayReservations: string[];
+    }): Promise<{
+        ok: boolean;
+        peerId: string;
+    }>;
+    heartbeat(input: {
+        peerId: string;
+        capabilities: DeviceCapabilities;
+        multiaddrs: string[];
+        relayReservations: string[];
+    }): Promise<{
+        ok: boolean;
+    }>;
+}
+interface DeviceNetworkService {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getLocalDevice(): Promise<Device>;
+    listDevices(): Promise<Device[]>;
+    observeDevices(listener: (devices: Device[]) => void): () => void;
+    listPairingSessions(): Promise<PairingSession[]>;
+    observePairingSessions(listener: (sessions: PairingSession[]) => void): () => void;
+    requestLocalPairing(peerId: string, options?: LocalPairingRequestOptions): Promise<PairingSession>;
+    acceptPairing(sessionId: string): Promise<void>;
+    rejectPairing(sessionId: string): Promise<void>;
+    removeTrustedDevice(peerId: string): Promise<void>;
+    openStream(peerId: string, protocol: MemeLoopProtocol, presentedGrant?: DeviceConnectionGrant): Promise<MemeLoopDuplexStream>;
+    sendRpc<T>(peerId: string, method: string, parameters: unknown, presentedGrant?: DeviceConnectionGrant): Promise<T>;
+    syncWithDevice(peerId: string, presentedGrant?: DeviceConnectionGrant): Promise<SyncResult>;
+    /** Configure Cloud connection. When set, syncCloudDevices() and CloudDeviceAuthorizer become available. */
+    configureCloud?(config: {
+        cloudUrl: string;
+        accessToken: string;
+    }): void;
+    /** Apply a Cloud-signed private relay admission token and connect to advertised relay/bootstrap peers. */
+    configureRelayReservation?(token: DeviceRelayReservationToken): Promise<void>;
+    /** Fetch devices from Cloud directory and persist into local trust store. Returns synced devices. */
+    syncCloudDevices?(): Promise<CloudDeviceRecord[]>;
+}
+interface ExchangeVersionVectorResult {
+    remoteVersion: VersionVector;
+    missingForRemote: ConversationMeta[];
+}
+interface AttachmentBlob {
+    data: Uint8Array;
+    filename: string;
+    mimeType: string;
+    size: number;
+}
+interface DeviceSyncTransport {
+    listPeers(): Promise<Device[]>;
+    exchangeVersionVector(peerId: string, localVersion: VersionVector): Promise<ExchangeVersionVectorResult>;
+    pullMissingMetadata(peerId: string, sinceVersion: VersionVector): Promise<ConversationMeta[]>;
+    pullMissingMessages(peerId: string, conversationId: string, knownMessageIds: string[]): Promise<ChatMessage[]>;
+    pullAttachmentBlob(peerId: string, contentHash: string): Promise<AttachmentBlob | null>;
+}
+
+export type { AgentExecutionLocation as A, PairingSessionStatus as B, CloudDeviceClient as C, Device as D, ExchangeVersionVectorResult as E, LocalDeviceIdentity as L, MemeLoopDuplexStream as M, PairingSession as P, SyncResult as S, TrustedDeviceRecord as T, AgentExecutionState as a, AttachmentBlob as b, CloudDeviceRecord as c, ConversationExecutionPlacement as d, DeviceAccountBindingRequest as e, DeviceAuthorizer as f, DeviceCapabilities as g, DeviceConnectionGrant as h, DeviceConnectionGrantVerificationInput as i, DeviceNetworkListenOptions as j, DeviceNetworkPath as k, DeviceNetworkService as l, DevicePlatform as m, DeviceProtocolDirection as n, DeviceReachability as o, DeviceReachabilityState as p, DeviceRelayReservationToken as q, DeviceRelayReservationTokenVerificationInput as r, DeviceRpcHandler as s, DeviceRpcHandlerInput as t, DeviceSyncTransport as u, DeviceTrustMode as v, DeviceTrustStore as w, LocalPairingRequestOptions as x, MemeLoopProtocol as y, PairingSessionDirection as z };

package/dist/types-CdFVSntj.d.ts

@@ -0,0 +1,255 @@
+import { V as VersionVector, C as ConversationMeta, b as ChatMessage } from './interface-IrKBFtL1.js';
+
+type DevicePlatform = 'desktop' | 'mobile' | 'cli';
+type DeviceTrustMode = 'local-pairing' | 'cloud-account';
+type DeviceReachabilityState = 'nearby' | 'online' | 'offline' | 'connecting';
+type DeviceNetworkPath = 'lan' | 'direct' | 'relay';
+type DeviceProtocolDirection = 'inbound' | 'outbound';
+type PairingSessionDirection = 'inbound' | 'outbound';
+type PairingSessionStatus = 'pending' | 'accepted' | 'rejected' | 'expired';
+type MemeLoopProtocol = '/memeloop/rpc/1.0.0' | '/memeloop/sync/1.0.0' | '/memeloop/agent/1.0.0' | '/memeloop/pairing/1.0.0' | '/memeloop/orchestration/1.0.0';
+interface DeviceCapabilities {
+    tools: string[];
+    mcpServers: string[];
+    hasWiki: boolean;
+    agentLoop?: boolean;
+    imChannels: string[];
+    wikis: Array<{
+        wikiId: string;
+        title?: string;
+        pathHint?: string;
+    }>;
+}
+interface LocalDeviceIdentity {
+    peerId: string;
+    publicKeyMultibase: string;
+    privateKeyRef: string;
+    privateKeyPkcs8Base64Url?: string;
+    privateKeyRawSeedBase64Url?: string;
+    createdAt: number;
+    deviceName: string;
+    platform: DevicePlatform;
+}
+interface DeviceNetworkListenOptions {
+    addresses: string[];
+    announce?: string[];
+}
+interface DeviceReachability {
+    state: DeviceReachabilityState;
+    paths: DeviceNetworkPath[];
+}
+interface Device {
+    peerId: string;
+    displayName: string;
+    platform: DevicePlatform;
+    trustMode: DeviceTrustMode;
+    trusted?: boolean;
+    reachability: DeviceReachability;
+    capabilities: DeviceCapabilities;
+    multiaddrs?: string[];
+    lastSeen?: number;
+}
+interface TrustedDeviceRecord {
+    peerId: string;
+    publicKeyMultibase: string;
+    deviceName: string;
+    platform: DevicePlatform;
+    trustMode: DeviceTrustMode;
+    accountId?: string;
+    createdAt: number;
+    lastSeen?: number;
+    revokedAt?: number;
+}
+interface DeviceTrustStore {
+    loadTrustedDevices(): Promise<TrustedDeviceRecord[]>;
+    saveTrustedDevice(record: TrustedDeviceRecord): Promise<void>;
+    removeTrustedDevice(peerId: string): Promise<void>;
+}
+interface DeviceAccountBindingRequest {
+    peerId: string;
+    publicKeyMultibase: string;
+    deviceName: string;
+    platform: DevicePlatform;
+    cloudNonce: string;
+    signature: string;
+}
+interface CloudDeviceRecord {
+    accountId: string;
+    peerId: string;
+    publicKeyMultibase: string;
+    deviceName: string;
+    platform: DevicePlatform;
+    capabilities: DeviceCapabilities;
+    multiaddrs: string[];
+    relayReservations: string[];
+    lastSeen: number;
+    revokedAt?: number;
+}
+interface DeviceConnectionGrant {
+    issuer: 'memeloop-cloud';
+    accountId: string;
+    subjectPeerId: string;
+    allowedPeerIds: string[];
+    issuedAt: number;
+    expiresAt: number;
+    signature: string;
+}
+interface DeviceConnectionGrantVerificationInput {
+    grant: DeviceConnectionGrant;
+    verificationPublicKeyMultibase: string;
+    subjectPeerId?: string;
+    allowedPeerId?: string;
+    now?: number;
+}
+interface DeviceRelayReservationToken {
+    issuer: 'memeloop-cloud';
+    accountId: string;
+    peerId: string;
+    relayMultiaddrs: string[];
+    bootstrapMultiaddrs: string[];
+    issuedAt: number;
+    expiresAt: number;
+    signature: string;
+}
+interface DeviceRelayReservationTokenVerificationInput {
+    token: DeviceRelayReservationToken;
+    verificationPublicKeyMultibase: string;
+    peerId?: string;
+    now?: number;
+}
+interface PairingSession {
+    sessionId: string;
+    localPeerId: string;
+    remotePeerId: string;
+    remotePublicKeyMultibase: string;
+    remoteDeviceName: string;
+    remotePlatform: DevicePlatform;
+    remoteCapabilities: DeviceCapabilities;
+    remoteMultiaddrs: string[];
+    direction: PairingSessionDirection;
+    status: PairingSessionStatus;
+    confirmCode: string;
+    createdAt: number;
+    expiresAt: number;
+}
+interface LocalPairingRequestOptions {
+    multiaddrs?: string[];
+}
+interface SyncResult {
+    ok: boolean;
+    peerId: string;
+    syncedAt: number;
+}
+interface MemeLoopDuplexStream {
+    source: AsyncIterable<Uint8Array>;
+    sink(source: AsyncIterable<Uint8Array>): Promise<void>;
+    close(): Promise<void>;
+}
+interface DeviceRpcHandlerInput {
+    remotePeerId: string;
+    method: string;
+    parameters: unknown;
+    presentedGrant?: DeviceConnectionGrant;
+}
+type DeviceRpcHandler = (input: DeviceRpcHandlerInput) => Promise<unknown>;
+type AgentExecutionLocation = {
+    kind: 'local';
+} | {
+    kind: 'device';
+    peerId: string;
+};
+type AgentExecutionState = 'idle' | 'running' | 'stopping';
+interface ConversationExecutionPlacement {
+    conversationId: string;
+    location: AgentExecutionLocation;
+    state: AgentExecutionState;
+    updatedAt: number;
+}
+interface DeviceAuthorizer {
+    canOpenProtocol(input: {
+        remotePeerId: string;
+        protocol: MemeLoopProtocol;
+        direction?: DeviceProtocolDirection;
+        presentedGrant?: DeviceConnectionGrant;
+    }): Promise<boolean>;
+}
+interface CloudDeviceClient {
+    listDevices(): Promise<CloudDeviceRecord[]>;
+    getConnectionGrantPublicKey(): Promise<{
+        issuer: string;
+        publicKeyMultibase: string;
+    }>;
+    createConnectionGrant(input: {
+        subjectPeerId: string;
+        allowedPeerIds: string[];
+    }): Promise<DeviceConnectionGrant>;
+    createRelayReservation(input: {
+        peerId: string;
+    }): Promise<DeviceRelayReservationToken>;
+    createBindingNonce(): Promise<{
+        nonce: string;
+        accountId: string;
+        expiresAt: string;
+    }>;
+    registerDevice(input: DeviceAccountBindingRequest & {
+        identity: LocalDeviceIdentity;
+        capabilities: DeviceCapabilities;
+        multiaddrs: string[];
+        relayReservations: string[];
+    }): Promise<{
+        ok: boolean;
+        peerId: string;
+    }>;
+    heartbeat(input: {
+        peerId: string;
+        capabilities: DeviceCapabilities;
+        multiaddrs: string[];
+        relayReservations: string[];
+    }): Promise<{
+        ok: boolean;
+    }>;
+}
+interface DeviceNetworkService {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    getLocalDevice(): Promise<Device>;
+    listDevices(): Promise<Device[]>;
+    observeDevices(listener: (devices: Device[]) => void): () => void;
+    listPairingSessions(): Promise<PairingSession[]>;
+    observePairingSessions(listener: (sessions: PairingSession[]) => void): () => void;
+    requestLocalPairing(peerId: string, options?: LocalPairingRequestOptions): Promise<PairingSession>;
+    acceptPairing(sessionId: string): Promise<void>;
+    rejectPairing(sessionId: string): Promise<void>;
+    removeTrustedDevice(peerId: string): Promise<void>;
+    openStream(peerId: string, protocol: MemeLoopProtocol, presentedGrant?: DeviceConnectionGrant): Promise<MemeLoopDuplexStream>;
+    sendRpc<T>(peerId: string, method: string, parameters: unknown, presentedGrant?: DeviceConnectionGrant): Promise<T>;
+    syncWithDevice(peerId: string, presentedGrant?: DeviceConnectionGrant): Promise<SyncResult>;
+    /** Configure Cloud connection. When set, syncCloudDevices() and CloudDeviceAuthorizer become available. */
+    configureCloud?(config: {
+        cloudUrl: string;
+        accessToken: string;
+    }): void;
+    /** Apply a Cloud-signed private relay admission token and connect to advertised relay/bootstrap peers. */
+    configureRelayReservation?(token: DeviceRelayReservationToken): Promise<void>;
+    /** Fetch devices from Cloud directory and persist into local trust store. Returns synced devices. */
+    syncCloudDevices?(): Promise<CloudDeviceRecord[]>;
+}
+interface ExchangeVersionVectorResult {
+    remoteVersion: VersionVector;
+    missingForRemote: ConversationMeta[];
+}
+interface AttachmentBlob {
+    data: Uint8Array;
+    filename: string;
+    mimeType: string;
+    size: number;
+}
+interface DeviceSyncTransport {
+    listPeers(): Promise<Device[]>;
+    exchangeVersionVector(peerId: string, localVersion: VersionVector): Promise<ExchangeVersionVectorResult>;
+    pullMissingMetadata(peerId: string, sinceVersion: VersionVector): Promise<ConversationMeta[]>;
+    pullMissingMessages(peerId: string, conversationId: string, knownMessageIds: string[]): Promise<ChatMessage[]>;
+    pullAttachmentBlob(peerId: string, contentHash: string): Promise<AttachmentBlob | null>;
+}
+
+export type { AgentExecutionLocation as A, PairingSessionStatus as B, CloudDeviceClient as C, Device as D, ExchangeVersionVectorResult as E, LocalDeviceIdentity as L, MemeLoopDuplexStream as M, PairingSession as P, SyncResult as S, TrustedDeviceRecord as T, AgentExecutionState as a, AttachmentBlob as b, CloudDeviceRecord as c, ConversationExecutionPlacement as d, DeviceAccountBindingRequest as e, DeviceAuthorizer as f, DeviceCapabilities as g, DeviceConnectionGrant as h, DeviceConnectionGrantVerificationInput as i, DeviceNetworkListenOptions as j, DeviceNetworkPath as k, DeviceNetworkService as l, DevicePlatform as m, DeviceProtocolDirection as n, DeviceReachability as o, DeviceReachabilityState as p, DeviceRelayReservationToken as q, DeviceRelayReservationTokenVerificationInput as r, DeviceRpcHandler as s, DeviceRpcHandlerInput as t, DeviceSyncTransport as u, DeviceTrustMode as v, DeviceTrustStore as w, LocalPairingRequestOptions as x, MemeLoopProtocol as y, PairingSessionDirection as z };