@delali/sirannon-db 0.1.4 → 0.1.5

package/dist/replication/index.d.ts

@@ -0,0 +1,491 @@
+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-B2byqt0B.js';
+export { F as ForwardedTransaction, N as NodeInfo, q as ReplicationChange, f as ReplicationTransport, g as TransportConfig } from '../types-B2byqt0B.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';
+import { EventEmitter } from 'node:events';
+import { C as ChangeTracker } from '../change-tracker-CFTQ9TSn.js';
+import { D as Database } from '../database-BVY1GqE7.js';
+import { a as SQLiteConnection } from '../types-BFSsG77t.js';
+import { P as Params, k as QueryOptions, T as Transaction, E as ExecuteResult } from '../types-D-74JiXb.js';
+import { S as SirannonError } from '../errors-C00ed08Q.js';
+import '../types-BeozgNPr.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;
+}
+
+/**
+ * Hybrid Logical Clock (HLC) for causal ordering of events across nodes.
+ *
+ * Each timestamp is encoded as `{wallMs hex}-{logical hex}-{nodeId}`, which
+ * is directly comparable with string comparison while preserving both
+ * wall-clock proximity and causal ordering guarantees. The wall-clock
+ * component tracks real time (milliseconds since epoch), the logical counter
+ * disambiguates events that occur within the same millisecond, and the nodeId
+ * ties the timestamp to its origin.
+ *
+ * Call `now()` before persisting a local write to generate a monotonically
+ * increasing timestamp. Call `receive(remote)` when processing a remote
+ * change to merge the remote clock into the local state, ensuring the local
+ * clock is never behind any observed timestamp.
+ */
+declare class HLC {
+    private wallMs;
+    private logical;
+    private readonly nodeId;
+    constructor(nodeId: string);
+    /** Generate a new HLC timestamp, advancing the clock. */
+    now(): string;
+    /** Merge a remote HLC timestamp into the local clock and return the updated value. */
+    receive(remote: string): string;
+    /** Lexicographic comparison of two encoded HLC strings. Returns -1, 0, or 1. */
+    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;
+}
+
+/**
+ * Persistent change log that bridges CDC events and the replication protocol.
+ *
+ * Composes specialised helpers: BatchReader (outbound batches), BatchApplier
+ * (inbound batches and conflict resolution), DumpOps (table dumps and
+ * manifests), SchemaOps (replication-table bootstrap, schema dump, wipe),
+ * StateOps (sequence and sync metadata), and PkResolver (cached primary-key
+ * lookups).
+ */
+declare class ReplicationLog {
+    private readonly changesTable;
+    private readonly pkResolver;
+    private readonly state;
+    private readonly schema;
+    private readonly batchReader;
+    private readonly batchApplier;
+    private readonly dump;
+    constructor(conn: SQLiteConnection, localNodeId: string, hlc: HLC, changesTable?: string, tracker?: ChangeTracker);
+    ensureReplicationTables(): Promise<void>;
+    readBatch(afterSeq: bigint, batchSize: number): Promise<ReplicationBatch | null>;
+    stampChanges(tx: SQLiteConnection, afterSeq: bigint, txId: string): Promise<void>;
+    updateColumnVersions(tx: SQLiteConnection, afterSeq: bigint): Promise<void>;
+    applyBatch(batch: ReplicationBatch, resolver: ConflictResolver | ((table: string) => ConflictResolver)): Promise<ApplyResult>;
+    getLastAppliedSeq(fromNodeId: string): Promise<bigint>;
+    setLastAppliedSeq(fromNodeId: string, seq: bigint): Promise<void>;
+    getPeerAckedSeq(peerNodeId: string): Promise<bigint>;
+    getLocalSeq(): Promise<bigint>;
+    recoverMaxObservedHlc(): Promise<string | null>;
+    getMinAckedSeq(): Promise<bigint | null>;
+    registerActiveSyncSeq(seq: bigint): void;
+    unregisterActiveSyncSeq(seq: bigint): void;
+    dumpTable(table: string, batchSize: number): AsyncGenerator<ReplicationBatch>;
+    dumpTableOnConnection(conn: SQLiteConnection, table: string, batchSize: number): AsyncGenerator<{
+        rows: Record<string, unknown>[];
+        checksum: string;
+        isLast: boolean;
+    }>;
+    dumpSchema(conn: SQLiteConnection, excludePrefix?: string): Promise<string[]>;
+    getTablesInFkOrder(conn: SQLiteConnection): Promise<string[]>;
+    wipeTables(conn: SQLiteConnection, tables: string[], tracker: ChangeTracker): Promise<void>;
+    setSyncTableStatus(table: string, status: string, rowCount?: number, pkHash?: string): Promise<void>;
+    setSyncMeta(phase: SyncPhase, snapshotSeq?: bigint, sourcePeerId?: string, requestId?: string): Promise<void>;
+    getSyncState(): Promise<{
+        phase: SyncPhase;
+        completedTables: string[];
+        snapshotSeq: bigint | null;
+        sourcePeerId: string | null;
+    }>;
+    isSyncCompleted(): Promise<boolean>;
+    generateManifest(conn: SQLiteConnection, table: string): Promise<SyncTableManifest>;
+    verifyManifest(manifest: SyncTableManifest): Promise<boolean>;
+}
+
+/**
+ * Maintains in-memory state for every peer the local node communicates with.
+ *
+ * For each peer, PeerTracker records the last acknowledged sequence number,
+ * the last sent sequence number, pending batch count, and connection status.
+ * This state drives two key mechanisms:
+ *
+ * - **Back-pressure**: the sender loop in ReplicationEngine checks
+ *   `pendingBatches` against the configured max before queuing more work
+ *   for a given peer.
+ * - **Write concern**: callers can await `waitForMajority` or `waitForAll`
+ *   with a sequence number and timeout. These methods resolve once enough
+ *   peers have acknowledged that sequence, or reject with a
+ *   WriteConcernError on timeout.
+ */
+declare class PeerTracker {
+    private readonly peers;
+    private readonly waiters;
+    addPeer(nodeId: string): void;
+    removePeer(nodeId: string): void;
+    onAckReceived(nodeId: string, ackedSeq: bigint): void;
+    recordInFlightBatch(nodeId: string, batch: InFlightBatch): void;
+    expireTimedOutBatches(nodeId: string, nowMs: number, timeoutMs: number): boolean;
+    getPeerState(nodeId: string): PeerState | undefined;
+    connectedPeerCount(): number;
+    waitForMajority(seq: bigint, timeoutMs: number): Promise<void>;
+    waitForAll(seq: bigint, timeoutMs: number): Promise<void>;
+    waitForConfiguredMajority(seq: bigint, localNodeId: string, votingNodeIds: string[], timeoutMs: number): Promise<void>;
+    waitForConfiguredAll(seq: bigint, localNodeId: string, votingNodeIds: string[], timeoutMs: number): Promise<void>;
+    ackedConfiguredNodeIds(seq: bigint, localNodeId: string, votingNodeIds: string[]): string[];
+    allPeerStates(): PeerState[];
+    private countAcked;
+    private countAckedConfigured;
+    private checkWaiters;
+}
+
+declare class LocalExecutor {
+    private readonly engine;
+    /**
+     * Serialises every `executeTransactionLocally` call against itself.
+     *
+     * Reason: SQLite only allows one active transaction per connection; the
+     * writer pool exposes a single writer connection (see `ConnectionPool`).
+     * Two parallel `engine.transaction(fn)` callers therefore both reach
+     * `await conn.exec('BEGIN')` on the same connection, and the second
+     * `BEGIN` errors with "cannot start a transaction within a transaction".
+     * Chaining onto this promise turns the second caller into a strict
+     * follow-on without changing the public API. A rejection is swallowed at
+     * the chain level so a failed transaction never poisons the queue; the
+     * original error still surfaces to the caller that initiated it.
+     */
+    private transactionQueue;
+    constructor(engine: ReplicationEngine);
+    executeLocally(sql: string, params?: Params, options?: QueryOptions): Promise<{
+        changes: number;
+        lastInsertRowId: number | bigint;
+    }>;
+    executeForwardedLocally(statements: Array<{
+        sql: string;
+        params?: Params;
+    }>): Promise<ForwardedTransactionResult>;
+    executeTransactionLocally<T>(fn: (tx: Transaction) => Promise<T>, options?: QueryOptions): Promise<T>;
+    private runTransaction;
+}
+
+declare class SenderLoop {
+    private readonly engine;
+    private senderTimer;
+    constructor(engine: ReplicationEngine);
+    start(): void;
+    stop(): void;
+    private updatePruneBoundary;
+    private sendPendingBatches;
+    private shouldReplicateTo;
+}
+
+declare class SyncJoiner {
+    private readonly engine;
+    private catchUpCheckTimer;
+    constructor(engine: ReplicationEngine);
+    initiateSync(): Promise<void>;
+    handleSyncBatchReceived(batch: SyncBatch, fromPeerId: string): Promise<void>;
+    handleSyncCompleteReceived(complete: SyncComplete, fromPeerId: string): Promise<void>;
+    startCatchUpCheck(): void;
+    stopCatchUpCheck(): void;
+    private sendSyncAck;
+    private finishCatchUpAsReady;
+}
+
+interface ActiveSyncSession {
+    requestId: string;
+    joinerNodeId: string;
+    readConn: SQLiteConnection;
+    snapshotSeq: bigint;
+    tables: string[];
+    completedTables: Set<string>;
+    startedAt: number;
+    timeoutTimer: ReturnType<typeof setTimeout>;
+    aborted: boolean;
+}
+interface SyncAckWaiter {
+    resolve: (ack: SyncAck) => void;
+    timer: ReturnType<typeof setTimeout>;
+}
+
+declare class SyncServer {
+    private readonly engine;
+    readonly activeSyncs: Map<string, ActiveSyncSession>;
+    readonly syncAckWaiters: Map<string, SyncAckWaiter>;
+    constructor(engine: ReplicationEngine);
+    handleSyncRequest(request: SyncRequest, fromPeerId: string): Promise<void>;
+    handleSyncAckReceived(ack: SyncAck): void;
+    abortSyncSession(requestId: string): void;
+    abortAll(): void;
+    abortSessionsForPeer(peerId: string): void;
+    private waitForSyncAck;
+    private sendSyncBatchAndWaitForAck;
+    private serveSyncSession;
+}
+
+/**
+ * Coordinates replication for a single database node.
+ *
+ * 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.
+ */
+declare class ReplicationEngine extends EventEmitter {
+    readonly database: Database;
+    readonly writerConn: SQLiteConnection;
+    readonly config: ReplicationConfig;
+    readonly nodeId: string;
+    readonly hlc: HLC;
+    readonly log: ReplicationLog;
+    readonly peerTracker: PeerTracker;
+    readonly defaultResolver: ConflictResolver;
+    readonly tracker: ChangeTracker | undefined;
+    readonly snapshotConnectionFactory: (() => Promise<SQLiteConnection>) | undefined;
+    readonly batchSize: number;
+    readonly batchIntervalMs: number;
+    readonly maxClockDriftMs: number;
+    readonly maxPendingBatches: number;
+    readonly maxBatchChanges: number;
+    readonly ackTimeoutMs: number;
+    readonly initialSync: boolean;
+    readonly syncBatchSize: number;
+    readonly maxConcurrentSyncs: number;
+    readonly maxSyncDurationMs: number;
+    readonly maxSyncLagBeforeReady: number;
+    readonly syncAckTimeoutMs: number;
+    readonly catchUpDeadlineMs: number;
+    readonly resumeFromSeq: bigint | undefined;
+    running: boolean;
+    coordinatorState: ReplicationGroupState | null;
+    coordinatorAuthority: boolean;
+    controllerState: 'disabled' | 'standby' | 'active' | 'lost';
+    private nodeSessionLeaseId;
+    private controllerLeaseId;
+    private coordinatorWatchDisposer;
+    private coordinatorLeaseTimer;
+    private controllerTimer;
+    private coordinatorRejoinSyncStarting;
+    lastSentSeq: bigint;
+    lastLocalSeq: bigint;
+    highestSourceSeqSeen: bigint;
+    readonly appliedSeqByPeer: Map<string, bigint>;
+    readonly expectedBatchIndex: Map<string, number>;
+    syncState: SyncState;
+    readonly localExecutor: LocalExecutor;
+    readonly syncServer: SyncServer;
+    readonly syncJoiner: SyncJoiner;
+    readonly senderLoop: SenderLoop;
+    constructor(database: Database, writerConn: SQLiteConnection, config: ReplicationConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    status(): ReplicationStatus;
+    getCurrentSeq(): bigint;
+    getAppliedSeq(peerId: string): bigint;
+    query<T>(sql: string, params?: Params, options?: QueryOptions): Promise<T[]>;
+    execute(sql: string, params?: Params, options?: QueryOptions): Promise<ExecuteResult>;
+    executeBatch(sql: string, paramsBatch: Params[], options?: QueryOptions): Promise<ExecuteResult[]>;
+    transaction<T>(fn: (tx: Transaction) => Promise<T>, options?: QueryOptions): Promise<T>;
+    forwardStatements(statements: Array<{
+        sql: string;
+        params?: Params;
+    }>, _options?: QueryOptions): Promise<ForwardedTransactionResult>;
+    startSenderLoop(): void;
+    emitError(event: ReplicationErrorEvent): void;
+    getResolver(table?: string): ConflictResolver;
+    checkClockDrift(remoteHlc: string): number;
+    refreshTriggersAfterDdl(): Promise<void>;
+    waitForWriteConcern(seq: bigint, wc: {
+        level: string;
+        timeoutMs?: number;
+    }): Promise<void>;
+    loadAppliedSeqs(): Promise<void>;
+    isCoordinatorMode(): boolean;
+    startCoordinatorMode(): Promise<void>;
+    prepareCoordinatorRejoinIfNeeded(): Promise<void>;
+    hasCoordinatorWriteAuthority(): boolean;
+    requiresCoordinatorRejoinSync(state?: ReplicationGroupState | null): boolean;
+    markCoordinatorSyncReady(): Promise<void>;
+    handleCoordinatorAckProgress(nodeId: string, ackedSeq: bigint): Promise<void>;
+    private removeLocalNodeFromCoordinatorInSyncSet;
+    verifyPrimaryAuthority(): Promise<ReplicationGroupState>;
+    assertInboundCoordinatorMessage(message: {
+        groupId?: string;
+        primaryTerm?: bigint;
+    }, fromPeerId: string, direction: 'batch' | 'ack' | 'forward' | 'sync-request' | 'sync-data'): Promise<void>;
+    decorateBatch(batch: ReplicationBatch): ReplicationBatch;
+    decorateAck(ack: ReplicationAck): ReplicationAck;
+    decorateForwardResult(result: ForwardedTransactionResult): ForwardedTransactionResult;
+    decorateSyncRequest(request: SyncRequest): SyncRequest;
+    decorateSyncBatch(batch: SyncBatch): SyncBatch;
+    decorateSyncComplete(complete: SyncComplete): SyncComplete;
+    decorateSyncAck(ack: SyncAck): SyncAck;
+    resolveWriteConcern(wc: {
+        level: string;
+        timeoutMs?: number;
+    } | undefined): {
+        level: string;
+        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. */
+declare class ReplicationError extends SirannonError {
+    readonly details?: Record<string, unknown> | undefined;
+    constructor(message: string, code?: string, details?: Record<string, unknown> | undefined);
+}
+/** Thrown when a write conflict cannot be resolved automatically. */
+declare class ConflictError extends ReplicationError {
+    readonly table: string;
+    readonly rowId: string;
+    constructor(message: string, table: string, rowId: string);
+}
+/** Thrown when inter-node communication fails. */
+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);
+}
+declare class ReadConcernError extends ReplicationError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+/** Thrown when a write or routing operation violates the configured topology rules. */
+declare class TopologyError extends ReplicationError {
+    constructor(message: string);
+}
+declare class CoordinatorError extends ReplicationError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+declare class AuthorityError extends ReplicationError {
+    constructor(message: string, code?: string, details?: Record<string, unknown>);
+}
+declare class StalePrimaryError extends AuthorityError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+declare class FailoverError extends ReplicationError {
+    constructor(message: string, code?: string, details?: Record<string, unknown>);
+}
+declare class NoSafePrimaryError extends FailoverError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+declare class NodeNotInSyncError extends ReplicationError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+declare class NodeDrainingError extends ReplicationError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+declare class ProtocolVersionMismatchError extends ReplicationError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+declare class UnsafeRecoveryRequiredError extends FailoverError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+/** Thrown for initial sync failures. */
+declare class SyncError extends ReplicationError {
+    readonly requestId?: string | undefined;
+    constructor(message: string, requestId?: string | undefined);
+}
+
+/** Generate a cryptographically random 32-hex-character node identifier. */
+declare function generateNodeId(): string;
+/** Throw a ReplicationError if the given string is not a valid 32-hex-character node ID. */
+declare function validateNodeId(id: string): void;
+
+/**
+ * Single-writer topology with one primary and one or more read-only replicas.
+ *
+ * Only the primary node accepts writes; replicas reject writes with a
+ * TopologyError (or forward them when writeForwarding is enabled on the
+ * engine). The primary replicates outbound batches only to peers whose role
+ * is 'replica', and replicas only accept inbound batches from a peer whose
+ * role is 'primary'. Conflict resolution is not required because a single
+ * writer eliminates concurrent write conflicts by design.
+ */
+declare class PrimaryReplicaTopology implements Topology {
+    readonly role: TopologyRole;
+    constructor(role: 'primary' | 'replica');
+    canWrite(): boolean;
+    shouldReplicateTo(_peerId: string, peerRole: TopologyRole): boolean;
+    shouldAcceptFrom(_peerId: string, peerRole: TopologyRole): boolean;
+    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 };