@delali/sirannon-db 0.1.7 → 0.2.0

package/dist/replication/index.d.ts

@@ -1,68 +1,18 @@
-import { C as ConflictResolver, h as ConflictContext, i as ConflictResolution, H as HLCTimestamp, R as ReplicationBatch, A as ApplyResult, j as SyncPhase, k as SyncTableManifest, I as InFlightBatch, P as PeerState, b as ForwardedTransactionResult, c as SyncBatch, d as SyncComplete, e as SyncAck, S as SyncRequest, l as ReplicationConfig, m as SyncState, n as ReplicationStatus, o as ReplicationErrorEvent, a as ReplicationAck, p as Topology, T as TopologyRole } from '../types-BsjobKbl.js';
-export { F as ForwardedTransaction, N as NodeInfo, q as ReplicationChange, f as ReplicationTransport, g as TransportConfig } from '../types-BsjobKbl.js';
-import { c as ReplicationGroupState } from '../types-BEu1I_9_.js';
-export { A as AcquireControllerLeaseInput, a as AcquireControllerLeaseResult, h as AdmitNodeToInSyncSetInput, C as ClusterCoordinator, f as CompareAndAdvancePrimaryTermInput, g as CompareAndAdvancePrimaryTermResult, j as CoordinatorCompatibilityMetadata, k as CoordinatorLease, b as CoordinatorNodeSession, l as CoordinatorPrimary, e as CoordinatorWatchDisposer, P as PromoteEligibleReplicaInput, R as RegisterNodeSessionInput, d as ReplicationGroupWatcher, S as SetReplicationGroupStateInput, U as UpdateInSyncSetInput, i as UpdateNodeMaintenanceInput } from '../types-BEu1I_9_.js';
+export { F as FieldMergeResolver, L as LWWResolver, P as PrimaryWinsResolver } from '../primary-wins-DPAm2AKG.js';
+import { H as HLCTimestamp, R as ReplicationBatch, C as ConflictResolver, A as ApplyResult, S as SyncTableManifest } from '../types-C_D8IhpO.js';
+export { a as ConflictContext, b as ConflictResolution, c as ReplicationChange } from '../types-C_D8IhpO.js';
+import { R as ReplicationGroupState, f as CoordinatorWatchDisposer } from '../types-BsVabqSI.js';
+export { A as AcquireControllerLeaseInput, b as AcquireControllerLeaseResult, i as AdmitNodeToInSyncSetInput, C as ClusterCoordinator, g as CompareAndAdvancePrimaryTermInput, h as CompareAndAdvancePrimaryTermResult, a as CoordinatorCompatibilityMetadata, k as CoordinatorLease, d as CoordinatorNodeSession, l as CoordinatorPrimary, P as PromoteEligibleReplicaInput, c as RegisterNodeSessionInput, e as ReplicationGroupWatcher, S as SetReplicationGroupStateInput, U as UpdateInSyncSetInput, j as UpdateNodeMaintenanceInput } from '../types-BsVabqSI.js';
 import { EventEmitter } from 'node:events';
-import { C as ChangeTracker } from '../change-tracker-CbmaMO-N.js';
-import { D as Database } from '../database-DuGp0Rtr.js';
-import { e as SQLiteConnection, P as Params, p as QueryOptions, T as Transaction, E as ExecuteResult } from '../types-D_hQW1hr.js';
-import { S as SirannonError } from '../errors-5Nf5ZAEC.js';
-import '../types-D4p4UyDK.js';
-
-type ColumnVersionGetter = (table: string, rowId: string) => Promise<Map<string, {
-    hlc: string;
-    nodeId: string;
-}>>;
-/**
- * Per-column conflict resolver that merges non-overlapping field changes.
- *
- * Given a conflict between a local and remote write on the same row, this
- * resolver computes the set of columns each side changed relative to the
- * common ancestor (oldData). If the changed column sets don't overlap, both
- * sides' changes are merged into a single row, avoiding unnecessary data
- * loss. When columns do overlap, per-column HLC versions (retrieved via the
- * injected `getColumnVersions` callback) determine which side's value wins
- * for each contested column. If no column version metadata exists, the
- * resolver falls back to whole-row LWW.
- */
-declare class FieldMergeResolver implements ConflictResolver {
-    private readonly getColumnVersions;
-    private readonly lww;
-    constructor(getColumnVersions: ColumnVersionGetter);
-    resolve(ctx: ConflictContext): Promise<ConflictResolution>;
-}
-
-/**
- * Last-Writer-Wins conflict resolver.
- *
- * Compares the remote HLC against the local HLC. The higher timestamp wins.
- * When both timestamps are equal (concurrent writes within the same
- * millisecond and logical tick), the tie is broken deterministically by
- * comparing node IDs lexicographically, so that every node reaches the same
- * resolution without coordination. This is the default resolver and the
- * fallback used by PrimaryWinsResolver and FieldMergeResolver when they
- * cannot make a more specific decision.
- */
-declare class LWWResolver implements ConflictResolver {
-    resolve(ctx: ConflictContext): ConflictResolution;
-}
-
-/**
- * Conflict resolver that unconditionally favors the designated primary node.
- *
- * If the remote change originated from the primary, it is accepted. If the
- * local change originated from the primary, the remote is rejected. When
- * neither side is the primary (e.g., two replicas syncing through a relay),
- * the decision falls back to LWW ordering. This resolver is designed for
- * primary-replica topologies where the primary is the authoritative source of
- * truth and replica-side writes should never override it.
- */
-declare class PrimaryWinsResolver implements ConflictResolver {
-    private readonly primaryNodeId;
-    private readonly lww;
-    constructor(primaryNodeId: string);
-    resolve(ctx: ConflictContext): ConflictResolution;
-}
+import { C as ChangeTracker } from '../change-tracker-DKRVUC3l.js';
+import { D as Database } from '../database-BY0L5Q2n.js';
+import { e as SQLiteConnection, P as Params, Q as QueryOptions, T as Transaction, E as ExecuteResult } from '../types-zhnRXrsb.js';
+import { g as SyncPhase, I as InFlightBatch, P as PeerState, a as ForwardedTransactionResult, b as SyncBatch, c as SyncComplete, d as SyncAck, S as SyncRequest, h as ReplicationConfig, i as SyncState, j as ReplicationStatus, k as ReplicationErrorEvent, R as ReplicationAck, l as Topology, f as TopologyRole } from '../types-B7gmEsZW.js';
+export { F as ForwardedTransaction, N as NodeInfo, e as ReplicationTransport, T as TransportConfig } from '../types-B7gmEsZW.js';
+import { S as SirannonError } from '../errors-Bw5MdNCu.js';
+import '../server-options-1JHu8pid.js';
+import '../operation-registry-9DcvxcE5.js';
+import '../types-CL6piSnD.js';
 
 /**
  * Hybrid Logical Clock (HLC) for causal ordering of events across nodes.
@@ -92,7 +42,7 @@ declare class HLC {
     static compare(a: string, b: string): number;
     /** Parse an encoded HLC string into its wall-clock, logical, and nodeId components. */
     static decode(hlc: string): HLCTimestamp;
-    private encode;
+    static encode(wallMs: number, logical: number, nodeId: string): string;
 }
 
 /**
@@ -111,6 +61,7 @@ declare class ReplicationLog {
     private readonly schema;
     private readonly batchReader;
     private readonly batchApplier;
+    private readonly stampOps;
     private readonly dump;
     constructor(conn: SQLiteConnection, localNodeId: string, hlc: HLC, changesTable?: string, tracker?: ChangeTracker);
     ensureReplicationTables(): Promise<void>;
@@ -227,16 +178,26 @@ declare class SenderLoop {
 declare class SyncJoiner {
     private readonly engine;
     private catchUpCheckTimer;
+    private readonly recovery;
     constructor(engine: ReplicationEngine);
     initiateSync(): Promise<void>;
     handleSyncBatchReceived(batch: SyncBatch, fromPeerId: string): Promise<void>;
     handleSyncCompleteReceived(complete: SyncComplete, fromPeerId: string): Promise<void>;
     startCatchUpCheck(): void;
     stopCatchUpCheck(): void;
+    stopTimers(): void;
+    isSourceRejection(ack: SyncAck, fromPeerId: string): boolean;
+    handleSourceRejection(ack: SyncAck, fromPeerId: string): void;
+    private retryInitiateSync;
     private sendSyncAck;
     private finishCatchUpAsReady;
 }
 
+interface TableStreamDigest {
+    rowCount: number;
+    digest: string;
+}
+
 interface ActiveSyncSession {
     requestId: string;
     joinerNodeId: string;
@@ -248,6 +209,8 @@ interface ActiveSyncSession {
     startedAt: number;
     timeoutTimer: ReturnType<typeof setTimeout>;
     aborted: boolean;
+    streamVerification: boolean;
+    tableDigests: Map<string, TableStreamDigest>;
 }
 interface SyncAckWaiter {
     resolve: (ack: SyncAck) => void;
@@ -259,6 +222,7 @@ declare class SyncServer {
     readonly activeSyncs: Map<string, ActiveSyncSession>;
     readonly syncAckWaiters: Map<string, SyncAckWaiter>;
     constructor(engine: ReplicationEngine);
+    private rejectSyncRequest;
     handleSyncRequest(request: SyncRequest, fromPeerId: string): Promise<void>;
     handleSyncAckReceived(ack: SyncAck): void;
     abortSyncSession(requestId: string): void;
@@ -266,6 +230,7 @@ declare class SyncServer {
     abortSessionsForPeer(peerId: string): void;
     private waitForSyncAck;
     private sendSyncBatchAndWaitForAck;
+    private refreshSessionDeadline;
     private serveSyncSession;
 }
 
@@ -274,8 +239,9 @@ declare class SyncServer {
  *
  * State and dependencies are exposed as readable properties so that the
  * collaborating modules in `./engine/` (LocalExecutor, SyncServer, SyncJoiner,
- * SenderLoop, transport wiring) can operate against a shared, mutable engine
- * instance without duplicating constructor wiring.
+ * SenderLoop, transport wiring, coordinator lifecycle/authority/membership)
+ * can operate against a shared, mutable engine instance without duplicating
+ * constructor wiring.
  */
 declare class ReplicationEngine extends EventEmitter {
     readonly database: Database;
@@ -306,17 +272,22 @@ declare class ReplicationEngine extends EventEmitter {
     coordinatorState: ReplicationGroupState | null;
     coordinatorAuthority: boolean;
     controllerState: 'disabled' | 'standby' | 'active' | 'lost';
-    private nodeSessionLeaseId;
-    private controllerLeaseId;
-    private coordinatorWatchDisposer;
-    private coordinatorLeaseTimer;
-    private controllerTimer;
-    private coordinatorRejoinSyncStarting;
+    nodeSessionLeaseId: string | null;
+    controllerLeaseId: string | null;
+    coordinatorWatchDisposer: CoordinatorWatchDisposer | null;
+    coordinatorLeaseTimer: ReturnType<typeof setInterval> | null;
+    controllerTimer: ReturnType<typeof setInterval> | null;
+    coordinatorRejoinSyncStarting: boolean;
+    coordinatorSessionRestoring: boolean;
+    coordinatorLastContactMs: number;
+    inSyncReconcileTimer: ReturnType<typeof setInterval> | null;
+    inSyncReconciling: boolean;
     lastSentSeq: bigint;
     lastLocalSeq: bigint;
     highestSourceSeqSeen: bigint;
     readonly appliedSeqByPeer: Map<string, bigint>;
     readonly expectedBatchIndex: Map<string, number>;
+    readonly syncTableDigests: Map<string, TableStreamDigest>;
     syncState: SyncState;
     readonly localExecutor: LocalExecutor;
     readonly syncServer: SyncServer;
@@ -335,7 +306,7 @@ declare class ReplicationEngine extends EventEmitter {
     forwardStatements(statements: Array<{
         sql: string;
         params?: Params;
-    }>, _options?: QueryOptions): Promise<ForwardedTransactionResult>;
+    }>, options?: QueryOptions): Promise<ForwardedTransactionResult>;
     startSenderLoop(): void;
     emitError(event: ReplicationErrorEvent): void;
     getResolver(table?: string): ConflictResolver;
@@ -353,7 +324,6 @@ declare class ReplicationEngine extends EventEmitter {
     requiresCoordinatorRejoinSync(state?: ReplicationGroupState | null): boolean;
     markCoordinatorSyncReady(): Promise<void>;
     handleCoordinatorAckProgress(nodeId: string, ackedSeq: bigint): Promise<void>;
-    private removeLocalNodeFromCoordinatorInSyncSet;
     verifyPrimaryAuthority(): Promise<ReplicationGroupState>;
     assertInboundCoordinatorMessage(message: {
         groupId?: string;
@@ -374,31 +344,6 @@ declare class ReplicationEngine extends EventEmitter {
         timeoutMs?: number;
     } | undefined;
     getCurrentPrimaryPeerId(): string | null;
-    private canAcceptLocalWrite;
-    private throwNotCurrentPrimary;
-    private assertReadConcern;
-    private refreshCoordinatorState;
-    private hasCurrentPrimaryAuthorityFor;
-    private getCoordinatorMessageFields;
-    private getForwardingPrimaryPeerId;
-    private updateCoordinatorProgressAfterWrite;
-    private startCoordinatorLeaseRenewal;
-    private startControllerLoop;
-    private controllerTick;
-    private runControllerPromotionCheck;
-    private handleCoordinatorStateUpdate;
-    private startCoordinatorRejoinSyncIfReady;
-    private handleFormerPrimaryDemotion;
-    private markLocalNodeRepairing;
-    private requiresCoordinatorRejoin;
-    private assertLocalCompatibility;
-    private evaluateFormerPrimaryHistory;
-    private stopCoordinatorTimers;
-    private stopCoordinatorMode;
-    private localCoordinatorPrimary;
-    private unrefTimer;
-    private getCoordinatorRuntimeStatus;
-    private errorDetails;
 }
 
 /** Base error for all replication-related failures. */
@@ -406,6 +351,11 @@ declare class ReplicationError extends SirannonError {
     readonly details?: Record<string, unknown> | undefined;
     constructor(message: string, code?: string, details?: Record<string, unknown> | undefined);
 }
+/** Thrown when an incoming replication batch fails integrity checks (checksum, schema, clock drift). */
+declare class BatchValidationError extends ReplicationError {
+    constructor(message: string);
+}
+
 /** Thrown when a write conflict cannot be resolved automatically. */
 declare class ConflictError extends ReplicationError {
     readonly table: string;
@@ -416,10 +366,6 @@ declare class ConflictError extends ReplicationError {
 declare class TransportError extends ReplicationError {
     constructor(message: string);
 }
-/** Thrown when an incoming replication batch fails integrity checks (checksum, schema, clock drift). */
-declare class BatchValidationError extends ReplicationError {
-    constructor(message: string);
-}
 /** Thrown when a write-concern quorum is not met within the configured timeout. */
 declare class WriteConcernError extends ReplicationError {
     constructor(message: string);
@@ -488,4 +434,4 @@ declare class PrimaryReplicaTopology implements Topology {
     requiresConflictResolution(): boolean;
 }
 
-export { ApplyResult, AuthorityError, BatchValidationError, ConflictContext, ConflictError, ConflictResolution, ConflictResolver, CoordinatorError, FailoverError, FieldMergeResolver, ForwardedTransactionResult, HLC, HLCTimestamp, LWWResolver, NoSafePrimaryError, NodeDrainingError, NodeNotInSyncError, PeerState, PeerTracker, PrimaryReplicaTopology, PrimaryWinsResolver, ProtocolVersionMismatchError, ReadConcernError, ReplicationAck, ReplicationBatch, ReplicationConfig, ReplicationEngine, ReplicationError, ReplicationErrorEvent, ReplicationGroupState, ReplicationLog, ReplicationStatus, StalePrimaryError, SyncAck, SyncBatch, SyncComplete, SyncError, SyncPhase, SyncRequest, SyncState, SyncTableManifest, Topology, TopologyError, TopologyRole, TransportError, UnsafeRecoveryRequiredError, WriteConcernError, generateNodeId, validateNodeId };
+export { ApplyResult, AuthorityError, BatchValidationError, ConflictError, ConflictResolver, CoordinatorError, CoordinatorWatchDisposer, FailoverError, ForwardedTransactionResult, HLC, HLCTimestamp, NoSafePrimaryError, NodeDrainingError, NodeNotInSyncError, PeerState, PeerTracker, PrimaryReplicaTopology, ProtocolVersionMismatchError, ReadConcernError, ReplicationAck, ReplicationBatch, ReplicationConfig, ReplicationEngine, ReplicationError, ReplicationErrorEvent, ReplicationGroupState, ReplicationLog, ReplicationStatus, StalePrimaryError, SyncAck, SyncBatch, SyncComplete, SyncError, SyncPhase, SyncRequest, SyncState, SyncTableManifest, Topology, TopologyError, TopologyRole, TransportError, UnsafeRecoveryRequiredError, WriteConcernError, generateNodeId, validateNodeId };