@agentunion/fastaun 0.5.20 → 0.5.22

package/dist/client/delivery.d.ts

@@ -1,6 +1,11 @@
-import type { EventPayload } from '../events.js';
+import type { ApplicationMessageReservation, EventHandler, EventPayload } from '../events.js';
 import { type JsonObject, type Message, type RpcParams } from '../types.js';
 import type { ClientRuntime } from './runtime.js';
+type PeerTailVersion = {
+    context: string;
+    push: object | undefined;
+    catalog: object | null;
+};
 type InlineRowVersion = 'v1' | 'v2';
 type DeliveryChangeContext = {
     generation: number;
@@ -31,7 +36,81 @@ export declare class MessageDeliveryEngine {
     private readonly volatileSeenMessages;
     private readonly volatileInFlightMessages;
     private seqTrackerWriteChain;
+    private peerCatalogTask;
+    private peerCatalogDirty;
+    private readonly peerCatalogQueries;
+    private peerContext;
+    private peerTracker;
+    private peerContextGeneration;
+    private peerBootstrap;
+    private readonly initializedPeers;
+    private readonly committedSeqTrackerStates;
+    private readonly seqTrackerNamespaceGenerations;
+    private readonly peerRecoveryTasks;
+    private readonly peerRecoveryNeeds;
+    private readonly peerForwardNeeds;
+    private readonly peerPushVersions;
+    private peerCatalogVersion;
+    private readonly peerPullHints;
+    private readonly peerPullConfirmedThrough;
+    private readonly peerServerConfirmedAcks;
+    private readonly peerVolatileCursors;
+    private readonly settledDeliveries;
+    private readonly deliveryInflight;
+    private readonly applicationPage;
+    private readonly applicationClaims;
+    private readonly volatileCompletions;
+    private readonly peerPageChains;
+    private readonly automaticPullFailures;
+    private readonly terminalGroupPulls;
+    private readonly automaticPullOperations;
+    private readonly automaticPullContext;
+    private automaticPullAbort;
     constructor(runtime: ClientRuntime);
+    private resetAutomaticPullBackoff;
+    private groupPullNamespace;
+    private automaticGroupPullStopped;
+    observeSuccessfulGroupPull(namespace: string): void;
+    private stopAutomaticGroupPull;
+    automaticPullRetryAt(namespace: string, operation: () => Promise<unknown>): number;
+    runPeerPullAttempt<T>(namespace: string, operation: () => Promise<T>, schedule: (attempt: () => Promise<T>) => Promise<T>): Promise<T>;
+    private runAutomaticPull;
+    private currentApplicationPage;
+    private isApplicationPageCurrent;
+    private ensureApplicationPageCurrent;
+    snapshotApplicationHandlers(): ReadonlyMap<string, readonly EventHandler[]> | undefined;
+    private hasP2pApplicationSubscription;
+    runApplicationPage<T>(namespace: string, source: string, operation: () => Promise<T>, reservation?: ApplicationMessageReservation, snapshot?: ReadonlyMap<string, readonly EventHandler[]>): Promise<T>;
+    private completeApplicationDelivery;
+    private applicationNamespace;
+    private applicationClaimKey;
+    private waitForApplicationOwner;
+    private collectApplicationEvent;
+    peerNamespace(senderAid: string): string;
+    runPeerPageSerialized<T>(namespace: string, operation: () => Promise<T>): Promise<T>;
+    hasPeerPageActivity(namespace: string): boolean;
+    peerAckChanged(): void;
+    peerPullPriority(namespace: string): number;
+    consumePeerPullHint(namespace: string, coveredThroughSeq: number, nextPendingSeq?: number): void;
+    peerSender(namespace: string): string;
+    private ensurePeerContext;
+    peerOwnType(): string;
+    initializePeer(senderAid: string, initialAfterSeq?: number): Promise<string>;
+    peerCommittedAck(namespace: string): number;
+    observePeerServerAck(namespace: string, sequence: number): void;
+    rememberCommittedSeqState(namespace: string): void;
+    private isReliableSeqNamespace;
+    captureSeqNamespaceGeneration(namespace: string): string;
+    isSeqNamespaceGenerationCurrent(namespace: string, generation: string): boolean;
+    peers(params?: Record<string, unknown>, background?: boolean): Promise<Record<string, unknown>>;
+    private queryPeers;
+    capturePeerTailVersion(senderAid: string): PeerTailVersion;
+    isPeerTailCurrent(senderAid: string, version: PeerTailVersion, committedAck: number): boolean;
+    shouldTailPeer(namespace: string, head: number, limit: number, expectedForwardNeed?: object): boolean;
+    private canClosePeerTail;
+    pullPeers(params?: Record<string, unknown>, background?: boolean): Promise<Record<string, unknown>>;
+    refreshPendingPeers(): void;
+    schedulePeerRecovery(sender: string, head?: number, volatile?: boolean): void;
     private isPullOperationCurrent;
     private ensurePullOperationCurrent;
     private isPullScopedSource;
@@ -45,11 +124,14 @@ export declare class MessageDeliveryEngine {
     volatileMessages(value: unknown): JsonObject[];
     private ensureVolatileContext;
     volatilePullCursor(): string;
+    peerVolatilePullCursor(sender: string): string;
+    setPeerVolatilePullCursor(sender: string, cursor: string): void;
     resetVolatilePullCursor(): void;
     private volatileSeenKey;
     isVolatileSeen(message: JsonObject): boolean;
     markVolatileSeen(message: JsonObject): void;
     beginVolatileDelivery(message: JsonObject): 'claimed' | 'seen' | 'inflight';
+    waitVolatileDelivery(message: JsonObject): Promise<void>;
     finishVolatileDelivery(message: JsonObject): void;
     publicVolatileMessage(message: JsonObject): JsonObject;
     ackVolatileMessages(messages: JsonObject[], v2: boolean, advanceCursor: boolean): Promise<unknown>;
@@ -98,6 +180,8 @@ export declare class MessageDeliveryEngine {
     private schedulePendingGroupPullIfNeeded;
     prunePushedSeqs(ns: string): void;
     markPublishedSeq(ns: string, seq: number): void;
+    private hasPublishedSeq;
+    private consumeOrderedMessage;
     enqueueOrderedMessage(ns: string, event: string, seq: number, payload: EventPayload, source?: string): void;
     isGroupEventNamespace(ns: string): boolean;
     publishOrderedQueueItem(ns: string, event: string, seq: number, payload: EventPayload, source: string, pullResponse?: boolean, deliveryContext?: DeliveryChangeContext): Promise<void>;
@@ -201,6 +285,7 @@ export declare class MessageDeliveryEngine {
     onP2PV2AckResult(result: unknown, requestedSeq: number, generation?: number): void;
     onP2PV2PullAckResult(result: unknown, requestedSeq: number, generation: number): void;
     resolveP2PPullAckSeq(result: unknown, requestedSeq: number): number;
+    onPeerPush(data: EventPayload, expectedVersion?: InlineRowVersion): Promise<void>;
     onV2PushNotification(data: EventPayload, expectedVersion?: InlineRowVersion, inlineGeneration?: number): Promise<void>;
     enqueueOnlineUnreadHint(data: JsonObject): void;
     onRawGroupV2MessageCreated(data: EventPayload, expectedVersion?: InlineRowVersion, inlineGeneration?: number): Promise<void>;
@@ -229,5 +314,6 @@ export declare class MessageDeliveryEngine {
     publishOrderedMessage(event: string, ns: string, seq: unknown, payload: EventPayload, source?: string): Promise<boolean>;
     private publishOrderedMessageInternal;
     publishPulledMessage(event: string, ns: string, seq: unknown, payload: EventPayload, persist?: boolean, source?: string): Promise<boolean>;
+    private publishPulledMessageInternal;
 }
 export {};