@quantiya/codevibe-codex-plugin 2.0.63 → 2.0.65

package/node_modules/@quantiya/codevibe-core/dist/appsync/sync-desktop-registration.d.ts

@@ -0,0 +1,133 @@
+import { z } from 'zod';
+import type { DesktopSyncSessionScope } from './sync-operation-journal';
+import { DesktopSyncReadClient, type DesktopSyncReadCredential, type DesktopSyncRegistrationAttempt, type SyncHistoryPage, type SyncReadEvent, type SyncRecoveryTarget } from './sync-read-client';
+declare const record: z.ZodDiscriminatedUnion<"state", [z.ZodObject<{
+    state: z.ZodLiteral<"PENDING">;
+    clientOperationId: z.ZodString;
+    createdAtEpochMs: z.ZodNumber;
+    sessionId: z.ZodString;
+    sessionGenerationId: z.ZodString;
+    schemaVersion: z.ZodLiteral<1>;
+    kind: z.ZodLiteral<"DESKTOP_REGISTRATION">;
+    operationId: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    kind: "DESKTOP_REGISTRATION";
+    sessionId: string;
+    sessionGenerationId: string;
+    clientOperationId: string;
+    schemaVersion: 1;
+    state: "PENDING";
+    operationId: string;
+    createdAtEpochMs: number;
+}, {
+    kind: "DESKTOP_REGISTRATION";
+    sessionId: string;
+    sessionGenerationId: string;
+    clientOperationId: string;
+    schemaVersion: 1;
+    state: "PENDING";
+    operationId: string;
+    createdAtEpochMs: number;
+}>, z.ZodObject<{
+    state: z.ZodLiteral<"READY">;
+    receipt: z.ZodObject<{
+        credential: z.ZodString;
+        expiresAtEpochMs: z.ZodNumber;
+        sessionId: z.ZodString;
+        sessionGenerationId: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        sessionId: string;
+        sessionGenerationId: string;
+        credential: string;
+        expiresAtEpochMs: number;
+    }, {
+        sessionId: string;
+        sessionGenerationId: string;
+        credential: string;
+        expiresAtEpochMs: number;
+    }>;
+    clientOperationId: z.ZodString;
+    createdAtEpochMs: z.ZodNumber;
+    sessionId: z.ZodString;
+    sessionGenerationId: z.ZodString;
+    schemaVersion: z.ZodLiteral<1>;
+    kind: z.ZodLiteral<"DESKTOP_REGISTRATION">;
+    operationId: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    kind: "DESKTOP_REGISTRATION";
+    sessionId: string;
+    sessionGenerationId: string;
+    clientOperationId: string;
+    schemaVersion: 1;
+    state: "READY";
+    operationId: string;
+    receipt: {
+        sessionId: string;
+        sessionGenerationId: string;
+        credential: string;
+        expiresAtEpochMs: number;
+    };
+    createdAtEpochMs: number;
+}, {
+    kind: "DESKTOP_REGISTRATION";
+    sessionId: string;
+    sessionGenerationId: string;
+    clientOperationId: string;
+    schemaVersion: 1;
+    state: "READY";
+    operationId: string;
+    receipt: {
+        sessionId: string;
+        sessionGenerationId: string;
+        credential: string;
+        expiresAtEpochMs: number;
+    };
+    createdAtEpochMs: number;
+}>]>;
+export type DesktopSyncRegistrationRecord = z.infer<typeof record>;
+export interface DesktopSyncRegistrationStore {
+    /** One durable operation per registration attempt; no periodic/network loop. */
+    credential(signal?: AbortSignal, revalidate?: boolean): Promise<DesktopSyncReadCredential>;
+    /** Exact stale credential only, after a typed server denial. A newer one is untouched. */
+    invalidate(stale: DesktopSyncReadCredential): Promise<boolean>;
+    /** Persist a validated socket receipt only for the credential that earned it. */
+    renew(current: DesktopSyncReadCredential, expiresAtEpochMs: number): Promise<DesktopSyncReadCredential>;
+}
+export declare function decodeDesktopSyncRegistration(value: unknown, invalid: () => never): DesktopSyncRegistrationRecord;
+/** Uses the existing bounded encrypted journal, account fence and scoped lock.
+ * Persist only the immutable operation ID before sending. Each retry signs a
+ * fresh authorization time. Network failure retains an unresolved operation;
+ * only READY expiry or a typed server disposition retires an expired intent. */
+export declare function createDesktopSyncRegistration(options: {
+    id: string;
+    scope: Readonly<DesktopSyncSessionScope>;
+    invalid(): never;
+    now(): number;
+    locked<T>(fn: (assertOwnership: () => Promise<void>) => Promise<T>): Promise<T>;
+    read(): Promise<DesktopSyncRegistrationRecord | null>;
+    write(row: DesktopSyncRegistrationRecord): Promise<void>;
+    register(attempt: DesktopSyncRegistrationAttempt, signal?: AbortSignal): Promise<DesktopSyncReadCredential>;
+}): DesktopSyncRegistrationStore;
+export interface DurableDesktopSyncReader {
+    credential(signal?: AbortSignal, revalidate?: boolean): Promise<DesktopSyncReadCredential>;
+    history(nextToken?: string, signal?: AbortSignal): Promise<SyncHistoryPage>;
+    gateResolution(promptId: string, signal?: AbortSignal): Promise<import('./sync-resolution-recovery').SyncResolutionResult>;
+    pendingInputs(nextToken?: string, signal?: AbortSignal): Promise<import('./sync-read-client').SyncPendingInputsPage>;
+    legacyPendingInputs(nextToken?: string, signal?: AbortSignal): Promise<import('./sync-read-client').SyncLegacyPendingInputsPage>;
+    pendingInput(target: import('./sync-read-client').SyncInputCoordinate, signal?: AbortSignal): Promise<SyncReadEvent | null>;
+    exact(target: {
+        eventId: string;
+        capability: string;
+        eventSha256: string;
+    }, signal?: AbortSignal): Promise<SyncReadEvent>;
+    recoverExact(target: SyncRecoveryTarget, signal?: AbortSignal): Promise<SyncReadEvent>;
+    recoverCurrent(target: SyncRecoveryTarget, signal?: AbortSignal): Promise<SyncReadEvent | null>;
+    executionReceipt(target: SyncRecoveryTarget, signal?: AbortSignal): Promise<import('./sync-read-client').SyncExecutedInput | null>;
+    renew(current: DesktopSyncReadCredential, expiresAtEpochMs: number): Promise<DesktopSyncReadCredential>;
+    close(): Promise<void>;
+}
+/** Live callers use this owner instead of managing an in-memory credential.
+ * A typed stale denial invalidates only the credential actually used. There
+ * is deliberately no implicit retry of history or a one-use exact fetch. */
+export declare function createDurableDesktopSyncReader(client: DesktopSyncReadClient, registration: DesktopSyncRegistrationStore): DurableDesktopSyncReader;
+export {};

package/node_modules/@quantiya/codevibe-core/dist/appsync/sync-event-client.d.ts

@@ -0,0 +1,110 @@
+import { type DeviceSigningKey } from '../local-executor/class-a-sign';
+import type { WriterEventAttestationInput } from '../types/events';
+export type SyncJson = null | boolean | number | string | SyncJson[] | {
+    [key: string]: SyncJson;
+};
+/** Mirrors the backend's closed customer-metered desktop status profile.
+ * Inclusion here never confers domain or CONTROL_ONLY authority. */
+export declare const PLAIN_DESKTOP_SYNC_TYPES: readonly ["TOOL_ACTIVITY", "NOTIFICATION", "MODE_SELECTED", "PLANNER_DECISION", "PLANNER_CACHE_HIT", "PLANNER_DEGRADED", "PLANNER_OUTAGE", "PLANNER_RECOVERED", "SLASH_COMMAND_INVOKED", "STRUCTURAL_SUMMARY_GENERATED", "LOCAL_AUTHORITY_REFUSAL", "TEAM_DECOMPOSED", "TEAM_TRACK_STATUS", "TEAM_GROUP_RESOLVED"];
+export type DesktopSyncEventType = 'USER_PROMPT' | 'ASSISTANT_RESPONSE' | 'REASONING' | 'TOOL_USE' | 'INTERACTIVE_PROMPT' | typeof PLAIN_DESKTOP_SYNC_TYPES[number];
+export declare const isPlainDesktopSyncType: (type: unknown) => boolean;
+interface SyncOperationIdentity {
+    /** Persist with the immutable operation before sending; never remint on retry. */
+    clientOperationId: string;
+    sessionId: string;
+    sessionGenerationId: string;
+    /** Use SESSION_KEY_GEN_ABSENT_SENTINEL only for a generation-absent session. */
+    expectedSessionKeyGen: string;
+}
+export type CreateDesktopSyncEventInput = SyncOperationIdentity & {
+    type: DesktopSyncEventType;
+    content?: string | null;
+    /** The JSON value, not an already AWSJSON-serialized string. Encrypted strings remain strings. */
+    metadata?: SyncJson;
+    /** Canonical UTC acceptance time, preserved through retries. Not an exact stored-key guarantee on collision. */
+    timestamp?: string;
+    /** Existing closed encrypted turn-writer profile; nonce equals clientOperationId. */
+    writerAttestation?: WriterEventAttestationInput;
+    /** Closed active-session E1 raise: all four fields required together. */
+    promptId?: string;
+    ownerToken?: string;
+    producerKind?: 'PLUGIN_APPROVAL' | 'CORE_OFFER';
+    mobileActionable?: boolean;
+} & ({
+    isEncrypted: true;
+    encryptionVersion: 1;
+} | {
+    isEncrypted: false;
+    encryptionVersion?: never;
+});
+export interface UpdateDesktopSyncEventInput extends SyncOperationIdentity {
+    eventId: string;
+    timestamp: string;
+    baseRevision: string;
+    immutableIdentityDigest: string;
+    metadataMerge: {
+        [key: string]: SyncJson;
+    };
+}
+export interface UpdateDesktopSyncStatusInput extends SyncOperationIdentity {
+    eventId: string;
+    timestamp: string;
+    deliveryStatus: 'DELIVERED' | 'EXECUTED';
+}
+/** Canonical control acknowledgement only; no fabricated Event payload. */
+export interface SyncStatusReceipt {
+    sessionId: string;
+    sessionGenerationId: string;
+    eventId: string;
+    timestamp: string;
+    type: 'USER_PROMPT' | 'PROMPT_RESPONSE';
+    source: 'MOBILE';
+    deliveryStatus: 'DELIVERED' | 'EXECUTED';
+    deliveredAt: string;
+    executedAt?: string;
+}
+export type SyncPromptRetentionReceipt = {
+    promptId: string;
+    status: 'REFRESHED';
+    expiresAt: number;
+} | {
+    promptId: string;
+    status: 'RERAISE_REQUIRED';
+};
+type DesktopSyncAction = 'CREATE_EVENT' | 'UPDATE_EVENT' | 'UPDATE_EVENT_STATUS';
+/** Acceptance identity only. Deliberately not Event: no payload or delivery claim. */
+export interface SyncEventReceipt {
+    eventId: string;
+    sessionId: string;
+    type: string;
+    source: 'DESKTOP' | 'MOBILE';
+    timestamp: string;
+    emittedBy: 'IMPLEMENTOR' | 'SYSTEM' | 'USER';
+}
+export declare class SyncEventClientError extends Error {
+    readonly code: 'INVALID_SYNC_INPUT' | 'INVALID_SYNC_RECEIPT' | 'INVALID_SYNC_STATE' | 'SYNC_IDENTITY_UNAVAILABLE' | 'SYNC_ACCOUNT_CHANGED' | 'SYNC_PRODUCER_FROZEN' | 'SYNC_SESSION_UNAVAILABLE' | 'SYNC_SESSION_GENERATION_CHANGED' | 'SYNC_SESSION_KEY_UNAVAILABLE';
+    constructor(code: 'INVALID_SYNC_INPUT' | 'INVALID_SYNC_RECEIPT' | 'INVALID_SYNC_STATE' | 'SYNC_IDENTITY_UNAVAILABLE' | 'SYNC_ACCOUNT_CHANGED' | 'SYNC_PRODUCER_FROZEN' | 'SYNC_SESSION_UNAVAILABLE' | 'SYNC_SESSION_GENERATION_CHANGED' | 'SYNC_SESSION_KEY_UNAVAILABLE');
+}
+export declare const SYNC_PROMPT_RAISE_FIELDS: readonly ["promptId", "ownerToken", "producerKind", "mobileActionable"];
+/** Same closed commitment as the backend. No key/transport work is performed. */
+export declare function snapshotSyncPromptRaise(value: Record<string, unknown>): {
+    promptId: string;
+    ownerToken: string;
+    producerKind: 'PLUGIN_APPROVAL' | 'CORE_OFFER';
+    mobileActionable: boolean;
+} | undefined;
+export declare function snapshotDesktopSyncInput(action: DesktopSyncAction, value: unknown): Record<string, SyncJson>;
+/** Hash AppSync's decoded AWSJSON values; serialize AWSJSON exactly once afterward. */
+export declare function signDesktopSyncInput(action: DesktopSyncAction | 'RESOLVE_PROMPT' | 'CONFIRM_RETIREMENT' | 'REPORT_SECURITY_POSTURE', data: Record<string, SyncJson>, userId: string, keys: DeviceSigningKey, issuedAtEpochMs: number): Readonly<Record<string, unknown>>;
+/** The optional server transition hint is not persisted as an Event receipt
+ * and never grants a route, quota or local PAUSED state. */
+export declare function parseSyncEventMutationResponse(value: unknown, expected: Record<string, SyncJson>): {
+    receipt: SyncEventReceipt;
+    refreshSyncState: boolean;
+};
+export declare function parseSyncEventReceipt(value: unknown, expected: Record<string, SyncJson>): SyncEventReceipt;
+export declare function parseSyncStatusReceipt(value: unknown, expected: Record<string, SyncJson>): SyncStatusReceipt;
+/** Only a canonical absence receipt permits re-raise; denial, malformed data,
+ * and an uncertain transaction outcome must never be interpreted as absence. */
+export declare function parseSyncPromptRetentionReceipt(value: unknown, promptId: string): SyncPromptRetentionReceipt;
+export {};

package/node_modules/@quantiya/codevibe-core/dist/appsync/sync-inbound-journal.d.ts

@@ -0,0 +1,142 @@
+import { z } from 'zod';
+import type { DesktopSyncSessionScope } from './sync-operation-journal';
+import type { SyncReadEvent, SyncRecoveryTarget } from './sync-read-client';
+declare const schema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    kind: z.ZodLiteral<"DESKTOP_INBOUND">;
+    operationId: z.ZodString;
+    sessionId: z.ZodString;
+    sessionGenerationId: z.ZodString;
+    entries: z.ZodArray<z.ZodObject<{
+        target: z.ZodObject<{
+            eventId: z.ZodString;
+            timestamp: z.ZodEffects<z.ZodString, string, string>;
+            eventRevision: z.ZodEffects<z.ZodString, string, string>;
+            eventSha256: z.ZodString;
+        }, "strict", z.ZodTypeAny, {
+            eventId: string;
+            timestamp: string;
+            eventSha256: string;
+            eventRevision: string;
+        }, {
+            eventId: string;
+            timestamp: string;
+            eventSha256: string;
+            eventRevision: string;
+        }>;
+        state: z.ZodEnum<["RECEIVED", "DISPATCHING", "HANDED_OFF", "UNCERTAIN"]>;
+        remoteExecuted: z.ZodBoolean;
+        localExecuted: z.ZodDefault<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        state: "RECEIVED" | "DISPATCHING" | "HANDED_OFF" | "UNCERTAIN";
+        target: {
+            eventId: string;
+            timestamp: string;
+            eventSha256: string;
+            eventRevision: string;
+        };
+        remoteExecuted: boolean;
+        localExecuted: boolean;
+    }, {
+        state: "RECEIVED" | "DISPATCHING" | "HANDED_OFF" | "UNCERTAIN";
+        target: {
+            eventId: string;
+            timestamp: string;
+            eventSha256: string;
+            eventRevision: string;
+        };
+        remoteExecuted: boolean;
+        localExecuted?: boolean | undefined;
+    }>, "many">;
+}, "strict", z.ZodTypeAny, {
+    kind: "DESKTOP_INBOUND";
+    entries: {
+        state: "RECEIVED" | "DISPATCHING" | "HANDED_OFF" | "UNCERTAIN";
+        target: {
+            eventId: string;
+            timestamp: string;
+            eventSha256: string;
+            eventRevision: string;
+        };
+        remoteExecuted: boolean;
+        localExecuted: boolean;
+    }[];
+    sessionId: string;
+    sessionGenerationId: string;
+    schemaVersion: 1;
+    operationId: string;
+}, {
+    kind: "DESKTOP_INBOUND";
+    entries: {
+        state: "RECEIVED" | "DISPATCHING" | "HANDED_OFF" | "UNCERTAIN";
+        target: {
+            eventId: string;
+            timestamp: string;
+            eventSha256: string;
+            eventRevision: string;
+        };
+        remoteExecuted: boolean;
+        localExecuted?: boolean | undefined;
+    }[];
+    sessionId: string;
+    sessionGenerationId: string;
+    schemaVersion: 1;
+    operationId: string;
+}>;
+export type DesktopInboundRecord = z.infer<typeof schema>;
+export declare class SyncInboundError extends Error {
+    readonly code: 'SYNC_INBOUND_INVALID' | 'SYNC_INBOUND_FULL' | 'SYNC_INBOUND_UNCERTAIN';
+    constructor(code: 'SYNC_INBOUND_INVALID' | 'SYNC_INBOUND_FULL' | 'SYNC_INBOUND_UNCERTAIN');
+}
+export declare function decodeDesktopInbound(value: unknown): DesktopInboundRecord;
+export interface DesktopInboundJournal {
+    /** Fsync a known coordinate before consuming its one-use capability. */
+    stage(value: SyncRecoveryTarget): Promise<'RECEIVED' | 'RETAINED'>;
+    /** Observe a current authenticated pending input, not an unverified hint.
+     * Unknown DELIVERED inputs are uncertain and must never be replayed. */
+    stageDiscovered(event: SyncReadEvent): Promise<'RECEIVED' | 'RETAINED'>;
+    /** Refresh an existing never-dispatched coordinate from current authority. */
+    refreshReceived(event: SyncReadEvent): Promise<'RECEIVED' | 'RETAINED'>;
+    /** A missing canonical row is not permission to execute a cached input. */
+    retainMissing(value: SyncRecoveryTarget): Promise<void>;
+    /** Only never-dispatched coordinates are safe to recover automatically. */
+    recoverable(): Promise<{
+        pending: readonly SyncRecoveryTarget[];
+        uncertain: number;
+    }>;
+    /** Coordinates only. Their payload must never be sent to a provider again. */
+    pendingAcknowledgements(): Promise<readonly SyncRecoveryTarget[]>;
+    /** Only a completed local handoff authorizes retrying its status write.
+     * An uncertain provider action is never converted into local success. */
+    hasCompletedHandoff(value: SyncRecoveryTarget): Promise<boolean>;
+    /** Persist the provider's explicit EXECUTED claim before cloud I/O.
+     * Callback completion alone may mean queued or rejected, not executed. */
+    markExecutedLocally(event: Parameters<DesktopInboundJournal['acknowledgeExecuted']>[0]): Promise<boolean>;
+    dispatch(event: SyncReadEvent, callback: () => Promise<void> | void, signal?: AbortSignal): Promise<'HANDED_OFF' | 'RETAINED'>;
+    /** A verified non-input needs no terminal-input handoff receipt. */
+    releaseNonInput(event: SyncReadEvent): Promise<void>;
+    /** Call only with a canonical cloud EXECUTED result, never a local send claim. */
+    acknowledgeExecuted(event: {
+        eventId: string;
+        timestamp: string;
+        sessionId: string;
+        sessionGenerationId: string;
+        source: string;
+        type: string;
+        deliveryStatus: string;
+    }): Promise<boolean>;
+}
+/** Shared journal persistence supplies encryption, account fencing and capacity.
+ * The short record lock never spans provider I/O; a distinct handoff lock does.
+ * A crash after DISPATCHING is uncertain, not permission to repeat terminal input.
+ * Healthy entries leave only after cloud EXECUTED + local handoff completion.
+ * The 64-entry limit bounds unresolved inputs, not lifetime session traffic. */
+export declare function createDesktopInbound(options: {
+    id: string;
+    scope: Readonly<DesktopSyncSessionScope>;
+    locked<T>(fn: (assertOwnership: () => Promise<void>) => Promise<T>): Promise<T>;
+    dispatchLocked<T>(fn: (assertOwnership: () => Promise<void>) => Promise<T>): Promise<T>;
+    read(): Promise<DesktopInboundRecord | null>;
+    write(row: DesktopInboundRecord): Promise<void>;
+}): DesktopInboundJournal;
+export {};

package/node_modules/@quantiya/codevibe-core/dist/appsync/sync-input-delivery.d.ts

@@ -0,0 +1,13 @@
+import { type Event, type UpdateEventStatusInput } from '../types/events';
+import { type SyncStatusReceipt } from './sync-event-client';
+export type MobileInputStatusUpdater = (input: UpdateEventStatusInput, requiredInput?: Pick<SyncStatusReceipt, 'sessionGenerationId' | 'type'>) => Promise<unknown>;
+/** The lifecycle marker comes from the authenticated R2 reader, never metadata. */
+export declare function requiresSyncInputDeliveryReceipt(event: Event): boolean;
+/**
+ * Before any terminal/planner side effect, require the exact cloud delivery
+ * receipt for R2. EXECUTED means a previous handoff won: do not route again.
+ * Legacy callers retain their existing best-effort error policy.
+ */
+export declare function acknowledgeMobileInputDelivery(update: MobileInputStatusUpdater, event: Event): Promise<boolean>;
+/** Validate the exact post-handoff receipt; failure must retain the tombstone. */
+export declare function acknowledgeMobileInputExecution(update: MobileInputStatusUpdater, event: Event): Promise<void>;

package/node_modules/@quantiya/codevibe-core/dist/appsync/sync-live-connection.d.ts

@@ -0,0 +1,87 @@
+import WebSocket from 'ws';
+import { DesktopSyncReadClient, type SyncReadEvent, type SyncRecoveryTarget, type SyncExecutedInput } from './sync-read-client';
+import type { DurableDesktopSyncReader } from './sync-desktop-registration';
+import type { DesktopSyncSessionScope } from './sync-operation-journal';
+import type { DesktopInboundJournal } from './sync-inbound-journal';
+/** One connection only. The existing subscription owner controls reconnects.
+ * Frames/hints are bounded before parsing; exact capabilities are never retried.
+ * Lost fetches use one charged exact-coordinate history request; ordinary
+ * history remains explicit and is never replayed into the agent callback. */
+export declare class DesktopSyncLiveConnection {
+    private readonly deps;
+    private readonly scope;
+    private readonly endpoint;
+    private readonly abort;
+    private ws?;
+    private credential?;
+    private generation?;
+    private phase;
+    private starting?;
+    private closing?;
+    private resolveReady?;
+    private rejectReady?;
+    private controlTimer?;
+    private pingTimer?;
+    private pongTimer?;
+    private heartbeatTimer?;
+    private recoveryTimer?;
+    private recoveryCursor?;
+    private recoveryItems;
+    private recoveryPages;
+    private legacyRecoveryActive;
+    private legacyRecoveryComplete;
+    private legacyRecoveryCursor?;
+    private legacyRecoveryItems;
+    private acknowledgementDueAt;
+    private acknowledgementAfter?;
+    private acknowledgementItems;
+    private pingNonce?;
+    private tail;
+    private statusRefresh?;
+    private queued;
+    private readonly seen;
+    private readonly beforeHello;
+    constructor(deps: {
+        endpoint: string;
+        environment: 'development' | 'production';
+        scope: DesktopSyncSessionScope;
+        wire: DesktopSyncReadClient;
+        reader: DurableDesktopSyncReader;
+        assertAccount(): void;
+        inbound: DesktopInboundJournal;
+        onUncertain?(count: number): void;
+        retryExecutionAcknowledgement?(target: SyncRecoveryTarget, signal: AbortSignal): Promise<SyncExecutedInput>;
+        onMaintenance?(signal: AbortSignal): Promise<void>;
+        onEvent(event: SyncReadEvent): Promise<void> | void;
+        onError(error: Error): void;
+        openSocket?: (url: string, options: WebSocket.ClientOptions) => WebSocket;
+        now?: () => number;
+    });
+    private now;
+    private fence;
+    private sameScope;
+    start(): Promise<void>;
+    private deadline;
+    private sendControl;
+    private message;
+    private enqueue;
+    /** Display recovery uses the existing accepted heartbeat, not another poll.
+     * It never gates readiness, input delivery, or connection maintenance. */
+    private refreshStatus;
+    private reconcileReceived;
+    private deliver;
+    /** One coordinate per queued step, yielding to live hints between steps.
+     * A completed handoff may also retry its fenced status-only acknowledgement.
+     * At most four 32-coordinate pages per burst; no Event bodies accumulate.
+     * Cursor is pagination only. Each completed pass restarts at the beginning
+     * after five minutes, including when a commit had an older timestamp. */
+    private scheduleDiscovery;
+    private discoveryStep;
+    private reconcileAcknowledgement;
+    private legacyDiscoveryStep;
+    private discoverCoordinate;
+    private startPings;
+    private fail;
+    history(nextToken?: string, signal?: AbortSignal): Promise<import("./sync-read-client").SyncHistoryPage>;
+    close(): Promise<void>;
+}