@delali/sirannon-db 0.1.4 → 0.1.5

package/dist/types-B2byqt0B.d.ts

@@ -0,0 +1,273 @@
+import { C as ChangeTracker } from './change-tracker-CFTQ9TSn.js';
+import { a as SQLiteConnection } from './types-BFSsG77t.js';
+import { C as ClusterCoordinator, j as CoordinatorCompatibilityMetadata, c as ReplicationGroupState } from './types-BEu1I_9_.js';
+
+interface NodeInfo {
+    id: string;
+    groupId?: string;
+    role: 'primary' | 'replica';
+    primaryTerm?: bigint;
+    protocolVersion?: string;
+    joinedAt: number;
+    lastSeenAt: number;
+    lastAckedSeq: bigint;
+    metadata?: Record<string, unknown>;
+}
+interface HLCTimestamp {
+    wallMs: number;
+    logical: number;
+    nodeId: string;
+}
+interface ReplicationChange {
+    table: string;
+    operation: 'insert' | 'update' | 'delete' | 'ddl';
+    rowId: string;
+    primaryKey: Record<string, unknown>;
+    hlc: string;
+    txId: string;
+    nodeId: string;
+    newData: Record<string, unknown> | null;
+    oldData: Record<string, unknown> | null;
+    ddlStatement?: string;
+}
+interface ReplicationBatch {
+    sourceNodeId: string;
+    batchId: string;
+    fromSeq: bigint;
+    toSeq: bigint;
+    hlcRange: {
+        min: string;
+        max: string;
+    };
+    changes: ReplicationChange[];
+    checksum: string;
+    groupId?: string;
+    primaryTerm?: bigint;
+}
+interface ReplicationAck {
+    batchId: string;
+    ackedSeq: bigint;
+    nodeId: string;
+    groupId?: string;
+    primaryTerm?: bigint;
+}
+interface ForwardedTransaction {
+    statements: Array<{
+        sql: string;
+        params?: Record<string, unknown> | unknown[];
+    }>;
+    requestId: string;
+    groupId?: string;
+    primaryTerm?: bigint;
+}
+interface ForwardedTransactionResult {
+    results: Array<{
+        changes: number;
+        lastInsertRowId: number | string;
+    }>;
+    requestId: string;
+    groupId?: string;
+    primaryTerm?: bigint;
+}
+interface ConflictContext {
+    table: string;
+    rowId: string;
+    localChange: ReplicationChange | null;
+    remoteChange: ReplicationChange;
+    localHlc: string | null;
+    remoteHlc: string;
+}
+interface ConflictResolution {
+    action: 'accept_remote' | 'keep_local' | 'merge';
+    mergedData?: Record<string, unknown>;
+}
+interface ConflictResolver {
+    resolve(ctx: ConflictContext): ConflictResolution | Promise<ConflictResolution>;
+}
+type TopologyRole = 'primary' | 'replica';
+interface Topology {
+    role: TopologyRole;
+    canWrite(): boolean;
+    shouldReplicateTo(peerId: string, peerRole: TopologyRole): boolean;
+    shouldAcceptFrom(peerId: string, peerRole: TopologyRole): boolean;
+    requiresConflictResolution(): boolean;
+}
+interface TransportConfig {
+    endpoints?: string[];
+    localRole?: TopologyRole;
+    groupId?: string;
+    primaryTerm?: bigint;
+    protocolVersion?: string;
+    metadata?: Record<string, unknown>;
+}
+interface ReplicationTransport {
+    connect(localNodeId: string, config: TransportConfig): Promise<void>;
+    disconnect(): Promise<void>;
+    send(peerId: string, batch: ReplicationBatch): Promise<void>;
+    broadcast(batch: ReplicationBatch): Promise<void>;
+    sendAck(peerId: string, ack: ReplicationAck): Promise<void>;
+    forward(peerId: string, request: ForwardedTransaction): Promise<ForwardedTransactionResult>;
+    requestSync(peerId: string, request: SyncRequest): Promise<void>;
+    sendSyncBatch(peerId: string, batch: SyncBatch): Promise<void>;
+    sendSyncComplete(peerId: string, complete: SyncComplete): Promise<void>;
+    sendSyncAck(peerId: string, ack: SyncAck): Promise<void>;
+    onBatchReceived(handler: (batch: ReplicationBatch, fromPeerId: string) => Promise<void>): void;
+    onAckReceived(handler: (ack: ReplicationAck, fromPeerId: string) => void): void;
+    onForwardReceived(handler: (request: ForwardedTransaction, fromPeerId: string) => Promise<ForwardedTransactionResult>): void;
+    onSyncRequested(handler: (request: SyncRequest, fromPeerId: string) => Promise<void>): void;
+    onSyncBatchReceived(handler: (batch: SyncBatch, fromPeerId: string) => Promise<void>): void;
+    onSyncCompleteReceived(handler: (complete: SyncComplete, fromPeerId: string) => Promise<void>): void;
+    onSyncAckReceived(handler: (ack: SyncAck, fromPeerId: string) => void): void;
+    onPeerConnected(handler: (peer: NodeInfo) => void): void;
+    onPeerDisconnected(handler: (peerId: string) => void): void;
+    peers(): ReadonlyMap<string, NodeInfo>;
+}
+interface InFlightBatch {
+    batchId: string;
+    fromSeq: bigint;
+    toSeq: bigint;
+    sentAt: number;
+}
+interface PeerState {
+    nodeId: string;
+    lastAckedSeq: bigint;
+    lastSentSeq: bigint;
+    lastReceivedHlc: string;
+    connected: boolean;
+    pendingBatches: number;
+    inFlightBatches: InFlightBatch[];
+}
+interface CoordinatorControllerConfig {
+    enabled?: boolean;
+    holderId?: string;
+    leaseTtlMs?: number;
+    tickIntervalMs?: number;
+}
+interface CoordinatorModeConfig {
+    clusterId: string;
+    groupId: string;
+    endpoint?: string;
+    votingDataBearingNodeIds?: string[];
+    coordinator: ClusterCoordinator;
+    sessionTtlMs?: number;
+    controller?: boolean | CoordinatorControllerConfig;
+    compatibility?: CoordinatorCompatibilityMetadata;
+}
+interface ReplicationConfig {
+    nodeId?: string;
+    topology: Topology;
+    transport: ReplicationTransport;
+    transportConfig?: TransportConfig;
+    writeForwarding?: boolean;
+    conflictResolvers?: Record<string, ConflictResolver>;
+    defaultConflictResolver?: ConflictResolver;
+    batchSize?: number;
+    batchIntervalMs?: number;
+    maxPendingBatches?: number;
+    snapshotThreshold?: number;
+    maxClockDriftMs?: number;
+    maxBatchChanges?: number;
+    ackTimeoutMs?: number;
+    onBeforeForwardedQuery?: (sql: string, params?: unknown[] | Record<string, unknown>) => void;
+    flowControl?: {
+        maxLagSeconds?: number;
+        onLagExceeded?: (peerId: string, lagMs: number) => void;
+    };
+    initialSync?: boolean;
+    syncBatchSize?: number;
+    maxConcurrentSyncs?: number;
+    maxSyncDurationMs?: number;
+    maxSyncLagBeforeReady?: number;
+    syncAckTimeoutMs?: number;
+    catchUpDeadlineMs?: number;
+    resumeFromSeq?: bigint;
+    snapshotConnectionFactory?: () => Promise<SQLiteConnection>;
+    changeTracker?: ChangeTracker;
+    coordinator?: CoordinatorModeConfig;
+}
+interface ReplicationStatus {
+    nodeId: string;
+    role: TopologyRole;
+    peers: PeerState[];
+    localSeq: bigint;
+    replicating: boolean;
+    syncState?: SyncState;
+    coordinator?: CoordinatorRuntimeStatus;
+}
+interface CoordinatorRuntimeStatus {
+    clusterId: string;
+    groupId: string;
+    currentPrimary: ReplicationGroupState['currentPrimary'];
+    primaryTerm: bigint;
+    inSyncNodeIds: string[];
+    drainingNodeIds: string[];
+    repairingNodeIds: string[];
+    faultedNodeIds: string[];
+    votingDataBearingNodeIds: string[];
+    authority: boolean;
+    controllerState: 'disabled' | 'standby' | 'active' | 'lost';
+}
+interface ApplyResult {
+    applied: number;
+    skipped: number;
+    conflicts: number;
+    droppedTables: string[];
+}
+type SyncPhase = 'pending' | 'syncing' | 'catching-up' | 'ready';
+interface SyncState {
+    phase: SyncPhase;
+    sourcePeerId: string | null;
+    snapshotSeq: bigint | null;
+    completedTables: string[];
+    totalTables: number;
+    startedAt: number | null;
+    error: string | null;
+}
+interface SyncRequest {
+    requestId: string;
+    joinerNodeId: string;
+    completedTables: string[];
+    groupId?: string;
+    primaryTerm?: bigint;
+}
+interface SyncBatch {
+    requestId: string;
+    table: string;
+    batchIndex: number;
+    rows: Record<string, unknown>[];
+    schema?: string[];
+    checksum: string;
+    isLastBatchForTable: boolean;
+    groupId?: string;
+    primaryTerm?: bigint;
+}
+interface SyncTableManifest {
+    table: string;
+    rowCount: number;
+    pkHash: string;
+}
+interface SyncComplete {
+    requestId: string;
+    snapshotSeq: bigint;
+    manifests: SyncTableManifest[];
+    groupId?: string;
+    primaryTerm?: bigint;
+}
+interface SyncAck {
+    requestId: string;
+    joinerNodeId: string;
+    table: string;
+    batchIndex: number;
+    success: boolean;
+    error?: string;
+    groupId?: string;
+    primaryTerm?: bigint;
+}
+interface ReplicationErrorEvent {
+    error: Error;
+    operation: string;
+    peerId?: string;
+    recoverable: boolean;
+}
+
+export type { ApplyResult as A, ConflictResolver as C, ForwardedTransaction as F, HLCTimestamp as H, InFlightBatch as I, NodeInfo as N, PeerState as P, ReplicationBatch as R, SyncRequest as S, TopologyRole as T, ReplicationAck as a, ForwardedTransactionResult as b, SyncBatch as c, SyncComplete as d, SyncAck as e, ReplicationTransport as f, TransportConfig as g, ConflictContext as h, ConflictResolution as i, SyncPhase as j, SyncTableManifest as k, ReplicationConfig as l, SyncState as m, ReplicationStatus as n, ReplicationErrorEvent as o, Topology as p, ReplicationChange as q };

package/dist/types-BEu1I_9_.d.ts

@@ -0,0 +1,139 @@
+type CoordinatorLeaseKind = 'controller' | 'node-session';
+type CoordinatorWatchDisposer = () => void | Promise<void>;
+interface CoordinatorLease {
+    id: string;
+    kind: CoordinatorLeaseKind;
+    clusterId: string;
+    holderId: string;
+    ttlMs: number;
+    grantedAtMs: number;
+    expiresAtMs: number;
+    metadata?: Record<string, unknown>;
+}
+interface AcquireControllerLeaseInput {
+    clusterId: string;
+    holderId: string;
+    ttlMs: number;
+    metadata?: Record<string, unknown>;
+}
+type AcquireControllerLeaseResult = {
+    acquired: true;
+    lease: CoordinatorLease;
+} | {
+    acquired: false;
+    lease: CoordinatorLease | null;
+};
+interface CoordinatorCompatibilityMetadata {
+    packageVersion?: string;
+    specVersion?: string;
+    protocolVersion?: string;
+}
+interface RegisterNodeSessionInput {
+    clusterId: string;
+    nodeId: string;
+    ttlMs: number;
+    endpoint?: string;
+    groupIds?: string[];
+    dataBearing?: boolean;
+    voting?: boolean;
+    compatibility?: CoordinatorCompatibilityMetadata;
+    metadata?: Record<string, unknown>;
+}
+interface CoordinatorNodeSession {
+    clusterId: string;
+    nodeId: string;
+    lease: CoordinatorLease;
+    endpoint?: string;
+    groupIds: string[];
+    dataBearing: boolean;
+    voting: boolean;
+    compatibility?: CoordinatorCompatibilityMetadata;
+    metadata?: Record<string, unknown>;
+}
+interface CoordinatorPrimary {
+    nodeId: string;
+    endpoint?: string;
+}
+interface ReplicationGroupState {
+    clusterId: string;
+    groupId: string;
+    votingDataBearingNodeIds: string[];
+    currentPrimary: CoordinatorPrimary | null;
+    primaryTerm: bigint;
+    durabilityPointSeq: bigint;
+    inSyncNodeIds: string[];
+    drainingNodeIds: string[];
+    repairingNodeIds: string[];
+    faultedNodeIds: string[];
+    compatibility?: CoordinatorCompatibilityMetadata;
+    updatedAtMs: number;
+}
+interface SetReplicationGroupStateInput {
+    clusterId: string;
+    groupId: string;
+    votingDataBearingNodeIds: string[];
+    currentPrimary?: CoordinatorPrimary | null;
+    primaryTerm?: bigint;
+    durabilityPointSeq?: bigint;
+    inSyncNodeIds?: string[];
+    drainingNodeIds?: string[];
+    repairingNodeIds?: string[];
+    faultedNodeIds?: string[];
+    compatibility?: CoordinatorCompatibilityMetadata;
+}
+interface CompareAndAdvancePrimaryTermInput {
+    clusterId: string;
+    groupId: string;
+    expectedPrimaryTerm: bigint;
+    nextPrimary: CoordinatorPrimary;
+}
+interface CompareAndAdvancePrimaryTermResult {
+    advanced: boolean;
+    state: ReplicationGroupState | null;
+}
+interface UpdateInSyncSetInput {
+    clusterId: string;
+    groupId: string;
+    inSyncNodeIds: string[];
+    durabilityPointSeq?: bigint;
+}
+interface AdmitNodeToInSyncSetInput {
+    clusterId: string;
+    groupId: string;
+    nodeId: string;
+    sourceNodeId: string;
+    appliedSeq: bigint;
+}
+interface UpdateNodeMaintenanceInput {
+    clusterId: string;
+    groupId: string;
+    nodeId: string;
+    draining?: boolean;
+    repairing?: boolean;
+    faulted?: boolean;
+}
+interface PromoteEligibleReplicaInput {
+    clusterId: string;
+    groupId: string;
+    excludeNodeIds?: string[];
+}
+type ReplicationGroupWatcher = (state: ReplicationGroupState) => void;
+interface ClusterCoordinator {
+    tryAcquireControllerLease(input: AcquireControllerLeaseInput): Promise<AcquireControllerLeaseResult>;
+    renewLease(leaseId: string, ttlMs: number): Promise<boolean>;
+    releaseLease(leaseId: string): Promise<boolean>;
+    registerNodeSession(input: RegisterNodeSessionInput): Promise<CoordinatorNodeSession>;
+    getLiveNodeSession(clusterId: string, nodeId: string): Promise<CoordinatorNodeSession | null>;
+    deregisterNodeSession(clusterId: string, nodeId: string): Promise<void>;
+    setReplicationGroupState(input: SetReplicationGroupStateInput): Promise<ReplicationGroupState>;
+    getReplicationGroupState(clusterId: string, groupId: string): Promise<ReplicationGroupState | null>;
+    watchReplicationGroup(clusterId: string, groupId: string, watcher: ReplicationGroupWatcher): CoordinatorWatchDisposer | Promise<CoordinatorWatchDisposer>;
+    compareAndAdvancePrimaryTerm(input: CompareAndAdvancePrimaryTermInput): Promise<CompareAndAdvancePrimaryTermResult>;
+    updateInSyncSet(input: UpdateInSyncSetInput): Promise<ReplicationGroupState | null>;
+    admitNodeToInSyncSet(input: AdmitNodeToInSyncSetInput): Promise<ReplicationGroupState | null>;
+    updateNodeMaintenance(input: UpdateNodeMaintenanceInput): Promise<ReplicationGroupState | null>;
+    promoteEligibleReplica(input: PromoteEligibleReplicaInput): Promise<ReplicationGroupState>;
+    close?(): Promise<void>;
+}
+
+export type { AcquireControllerLeaseInput as A, ClusterCoordinator as C, PromoteEligibleReplicaInput as P, RegisterNodeSessionInput as R, SetReplicationGroupStateInput as S, UpdateInSyncSetInput as U, AcquireControllerLeaseResult as a, CoordinatorNodeSession as b, ReplicationGroupState as c, ReplicationGroupWatcher as d, CoordinatorWatchDisposer as e, CompareAndAdvancePrimaryTermInput as f, CompareAndAdvancePrimaryTermResult as g, AdmitNodeToInSyncSetInput as h, UpdateNodeMaintenanceInput as i, CoordinatorCompatibilityMetadata as j, CoordinatorLease as k, CoordinatorPrimary as l };

package/dist/types-BeozgNPr.d.ts

@@ -0,0 +1,26 @@
+import { T as Transaction } from './types-D-74JiXb.js';
+
+interface AppliedMigration {
+    version: number;
+    name: string;
+    applied_at: number;
+}
+interface Migration {
+    version: number;
+    name: string;
+    up: string | ((tx: Transaction) => void | Promise<void>);
+    down?: string | ((tx: Transaction) => void | Promise<void>);
+}
+interface AppliedMigrationEntry {
+    version: number;
+    name: string;
+}
+interface MigrationResult {
+    applied: AppliedMigrationEntry[];
+    skipped: number;
+}
+interface RollbackResult {
+    rolledBack: AppliedMigrationEntry[];
+}
+
+export type { AppliedMigration as A, Migration as M, RollbackResult as R, MigrationResult as a, AppliedMigrationEntry as b };

package/dist/{types-DtDutWRU.d.ts → types-D-74JiXb.d.ts}

@@ -1,7 +1,48 @@
-import { S as SQLiteDriver } from './types-BFSsG77t.js';
+import { a as SQLiteConnection, S as SQLiteDriver } from './types-BFSsG77t.js';
+
+declare class Transaction {
+    private readonly conn;
+    private _lastInsertRowId;
+    constructor(conn: SQLiteConnection);
+    query<T = Record<string, unknown>>(sql: string, params?: Params): Promise<T[]>;
+    execute(sql: string, params?: Params): Promise<ExecuteResult>;
+    executeBatch(sql: string, paramsBatch: Params[]): Promise<ExecuteResult[]>;
+    get lastInsertRowId(): number | bigint;
+    static run<T>(conn: SQLiteConnection, fn: (tx: Transaction) => Promise<T>): Promise<T>;
+}
 
 /** Query parameter types: named (object) or positional (array). */
 type Params = Record<string, unknown> | unknown[];
+type WriteConcernLevel = 'local' | 'majority' | 'all';
+interface WriteConcern {
+    level: WriteConcernLevel;
+    timeoutMs?: number;
+}
+type ReadConcernLevel = 'local' | 'majority' | 'linearizable';
+interface ReadConcern {
+    level: ReadConcernLevel;
+}
+interface QueryOptions {
+    writeConcern?: WriteConcern;
+    readConcern?: ReadConcern;
+}
+interface ClusterReadEndpointInfo {
+    nodeId: string;
+    endpoint: string;
+    readConcerns: ReadConcernLevel[];
+}
+interface ClusterStatusInfo {
+    databaseId: string;
+    replicationGroupId?: string;
+    role?: 'primary' | 'replica';
+    currentPrimary?: {
+        nodeId: string;
+        endpoint?: string;
+    } | null;
+    primaryTerm?: bigint;
+    readEndpoints?: ClusterReadEndpointInfo[];
+    health: 'healthy' | 'degraded' | 'failing_over' | 'unavailable' | 'repairing' | 'syncing';
+}
 /** Result returned by mutation statements (INSERT, UPDATE, DELETE). */
 interface ExecuteResult {
     changes: number;
@@ -24,6 +65,8 @@ interface QueryHookContext {
     sql: string;
     params?: Params;
     metadata?: Record<string, unknown>;
+    writeConcern?: WriteConcern;
+    readConcern?: ReadConcern;
 }
 /** Hook invoked before a query is executed. Throw to deny. */
 type BeforeQueryHook = (ctx: QueryHookContext) => void | Promise<void>;
@@ -156,12 +199,42 @@ interface RequestDenial {
 }
 /** Middleware hook for auth, rate limiting, and request validation. */
 type OnRequestHook = (ctx: RequestContext) => undefined | RequestDenial | Promise<undefined | RequestDenial>;
+interface ServerExecutionTarget {
+    query<T = Record<string, unknown>>(sql: string, params?: Params, options?: QueryOptions): Promise<T[]>;
+    execute(sql: string, params?: Params, options?: QueryOptions): Promise<ExecuteResult>;
+    transaction<T>(fn: (tx: Transaction) => Promise<T>, options?: QueryOptions): Promise<T>;
+}
+type ServerExecutionTargetResolver = (databaseId: string) => ServerExecutionTarget | null | undefined | Promise<ServerExecutionTarget | null | undefined>;
 /** Options for the standalone HTTP + WS server. */
 interface ServerOptions {
     host?: string;
     port?: number;
     cors?: boolean | CorsOptions;
     onRequest?: OnRequestHook;
+    resolveExecutionTarget?: ServerExecutionTargetResolver;
+    getReplicationStatus?: () => ReplicationStatusInfo | null;
+    getClusterStatus?: (databaseId: string) => ClusterStatusInfo | null;
+}
+interface ReplicationStatusInfo {
+    role: string;
+    writeForwarding: boolean;
+    peers: number;
+    localSeq: bigint;
+    replicationGroupId?: string;
+    primaryTerm?: bigint;
+    currentPrimary?: string;
+    coordinator?: {
+        connected: boolean;
+        authority: boolean;
+    };
+    controller?: {
+        state: 'disabled' | 'standby' | 'active' | 'lost';
+    };
+    inSyncReplicas?: string[];
+    laggingReplicas?: string[];
+    syncState?: string;
+    readAvailability?: 'available' | 'unavailable';
+    writeAvailability?: 'available' | 'unavailable';
 }
 /** CORS configuration. */
 interface CorsOptions {
@@ -173,6 +246,7 @@ interface CorsOptions {
 interface WSHandlerOptions {
     /** Maximum message size in bytes. Default: 1_048_576 (1 MB). */
     maxPayloadLength?: number;
+    resolveExecutionTarget?: ServerExecutionTargetResolver;
 }
 /** Options for the client SDK. */
 interface ClientOptions {
@@ -180,10 +254,12 @@ interface ClientOptions {
     transport?: 'websocket' | 'http';
     /** Custom headers for HTTP requests. */
     headers?: Record<string, string>;
+    /** WebSocket subprotocols sent during the browser-compatible handshake. */
+    webSocketProtocols?: string | string[];
     /** Reconnect on WebSocket disconnect. Default: true. */
     autoReconnect?: boolean;
     /** Reconnect interval in ms. Default: 1000. */
     reconnectInterval?: number;
 }
 
-export type { AfterQueryHook as A, BeforeSubscribeHook as B, ConnectionHookContext as C, DatabaseOptions as D, ExecuteResult as E, HookConfig as H, LifecycleConfig as L, MetricsConfig as M, OnRequestHook as O, Params as P, QueryHookContext as Q, RequestContext as R, ServerOptions as S, WSHandlerOptions as W, QueryMetrics as a, ConnectionMetrics as b, CDCMetrics as c, SubscriptionBuilder as d, BackupScheduleOptions as e, BeforeQueryHook as f, SirannonOptions as g, BeforeConnectHook as h, DatabaseOpenHook as i, DatabaseCloseHook as j, ChangeEvent as k, ChangeOperation as l, ClientOptions as m, CorsOptions as n, RequestDenial as o, Subscription as p };
+export { type AfterQueryHook as A, type BeforeQueryHook as B, type ChangeEvent as C, type DatabaseOptions as D, type ExecuteResult as E, type HookConfig as H, type LifecycleConfig as L, type MetricsConfig as M, type OnRequestHook as O, type Params as P, type QueryHookContext as Q, type ReadConcern as R, type SirannonOptions as S, Transaction as T, type WriteConcern as W, type BeforeConnectHook as a, type DatabaseOpenHook as b, type DatabaseCloseHook as c, type ServerOptions as d, type WSHandlerOptions as e, type ConnectionHookContext as f, type BeforeSubscribeHook as g, type QueryMetrics as h, type ConnectionMetrics as i, type CDCMetrics as j, type QueryOptions as k, type SubscriptionBuilder as l, type BackupScheduleOptions as m, type ChangeOperation as n, type ClientOptions as o, type ClusterReadEndpointInfo as p, type ClusterStatusInfo as q, type CorsOptions as r, type ReadConcernLevel as s, type ReplicationStatusInfo as t, type RequestContext as u, type RequestDenial as v, type ServerExecutionTarget as w, type ServerExecutionTargetResolver as x, type Subscription as y, type WriteConcernLevel as z };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@delali/sirannon-db",
   "type": "module",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "A production-grade library that turns SQLite databases into a networked data layer with real-time subscriptions.",
   "author": "Delali (https://sondelali.com)",
   "license": "Apache-2.0",
@@ -65,6 +65,22 @@
     "./client": {
       "types": "./dist/client/index.d.ts",
       "import": "./dist/client/index.mjs"
+    },
+    "./replication": {
+      "types": "./dist/replication/index.d.ts",
+      "import": "./dist/replication/index.mjs"
+    },
+    "./replication/coordinator/etcd": {
+      "types": "./dist/replication/coordinator/etcd.d.ts",
+      "import": "./dist/replication/coordinator/etcd.mjs"
+    },
+    "./transport/memory": {
+      "types": "./dist/transport/memory.d.ts",
+      "import": "./dist/transport/memory.mjs"
+    },
+    "./transport/grpc": {
+      "types": "./dist/transport/grpc.d.ts",
+      "import": "./dist/transport/grpc.mjs"
     }
   },
   "files": [
@@ -76,39 +92,62 @@
     "node": ">=22"
   },
   "peerDependencies": {
+    "@bufbuild/protobuf": ">=2.0.0",
+    "@grpc/grpc-js": ">=1.10.0",
     "better-sqlite3": ">=12.0.0",
-    "wa-sqlite": ">=1.0.0",
-    "expo-sqlite": ">=14.0.0",
     "croner": ">=10.0.0",
-    "uWebSockets.js": ">=20.0.0"
+    "expo-sqlite": ">=14.0.0",
+    "etcd3": ">=1.1.2",
+    "grpc-health-check": ">=2.0.0",
+    "uWebSockets.js": ">=20.0.0",
+    "wa-sqlite": ">=1.0.0"
   },
   "peerDependenciesMeta": {
+    "@bufbuild/protobuf": {
+      "optional": true
+    },
+    "@grpc/grpc-js": {
+      "optional": true
+    },
     "better-sqlite3": {
       "optional": true
     },
-    "wa-sqlite": {
+    "croner": {
       "optional": true
     },
     "expo-sqlite": {
       "optional": true
     },
-    "croner": {
+    "etcd3": {
+      "optional": true
+    },
+    "grpc-health-check": {
       "optional": true
     },
     "uWebSockets.js": {
       "optional": true
+    },
+    "wa-sqlite": {
+      "optional": true
     }
   },
   "devDependencies": {
+    "@bufbuild/protobuf": "2.11.0",
+    "@grpc/grpc-js": "1.14.3",
     "@types/better-sqlite3": "7.6.13",
     "@types/node": "25.3.3",
-    "@types/pg": "8.11.10",
+    "@types/pg": "8.20.0",
     "@vitest/coverage-v8": "4.0.18",
     "better-sqlite3": "12.6.2",
     "croner": "10.0.1",
-    "pg": "8.19.0",
+    "etcd3": "1.1.2",
+    "grpc-health-check": "2.1.0",
+    "grpc-tools": "1.13.1",
+    "pg": "8.20.0",
+    "selfsigned": "5.5.0",
     "simple-statistics": "7.8.7",
     "tinybench": "6.0.0",
+    "ts-proto": "2.11.6",
     "tsup": "8.5.1",
     "tsx": "4.21.0",
     "typescript": "5.9.3",
@@ -119,7 +158,10 @@
     "build": "rm -rf dist && tsup",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
-    "typecheck": "tsc --noEmit",
+    "test:e2e": "vitest run --config vitest.e2e.config.ts",
+    "test:failover": "vitest run --config vitest.failover.config.ts",
+    "test:soak": "vitest run --config vitest.soak.config.ts",
+    "typecheck": "tsc --noEmit && tsc --noEmit -p tsconfig.test.json",
     "lint": "biome check .",
     "lint:fix": "biome check --write .",
     "format": "biome format --write .",
@@ -128,11 +170,13 @@
     "bench:ycsb": "node --expose-gc --import tsx benchmarks/ycsb/workload-a.ts",
     "bench:oltp": "node --expose-gc --import tsx benchmarks/oltp/tpc-c-lite.ts",
     "bench:scaling": "node --expose-gc --import tsx benchmarks/scaling/concurrency.ts",
+    "bench:pool": "node --expose-gc --import tsx benchmarks/scaling/pool-sweep.ts",
     "bench:cdc": "node --expose-gc --import tsx benchmarks/sirannon/cdc-latency.ts",
     "bench:docker": "node --import tsx benchmarks/run-docker.ts",
     "bench:docker:e2e": "node --import tsx benchmarks/run-e2e.ts",
     "bench:docker:engine": "node --expose-gc --import tsx benchmarks/run-engine.ts",
     "bench:statistical": "node --expose-gc --import tsx benchmarks/run-statistical.ts",
-    "bench:charts": "python3 benchmarks/scripts/generate-charts.py benchmarks/results/"
+    "bench:charts": "python3 benchmarks/scripts/generate-charts.py benchmarks/results/",
+    "proto:gen": "grpc_tools_node_protoc --plugin=protoc-gen-ts_proto=./node_modules/.bin/protoc-gen-ts_proto --ts_proto_out=src/transport/grpc/generated --ts_proto_opt=forceLong=bigint --ts_proto_opt=esModuleInterop=true --ts_proto_opt=outputServices=grpc-js --ts_proto_opt=env=node -I src/transport/grpc/proto src/transport/grpc/proto/replication.proto"
   }
 }