dandelion-mesh 1.0.0

package/build/main/raft/RaftNode.js

@@ -0,0 +1,443 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RaftNode = void 0;
+/**
+ * Core Raft consensus node.
+ *
+ * This class implements the Raft algorithm for leader election and log
+ * replication. It is transport-agnostic — the caller must wire up
+ * `sendMessage` to deliver RPCs, and call `handleMessage` when RPCs arrive.
+ *
+ * Log indices are 1-based per the Raft paper.
+ */
+class RaftNode {
+    constructor(id, log, options) {
+        var _a, _b, _c;
+        this.role = 'follower';
+        this.currentTerm = 0;
+        this.votedFor = null;
+        this.leaderId = null;
+        // Volatile state (all servers)
+        this.commitIndex = 0;
+        this.lastApplied = 0;
+        // Volatile state (leader only)
+        this.nextIndex = new Map();
+        this.matchIndex = new Map();
+        // Election / heartbeat timers
+        this.electionTimer = null;
+        this.heartbeatTimer = null;
+        // Cluster membership (peer IDs excluding self)
+        this.peers = [];
+        // Votes received in current election
+        this.votesReceived = new Set();
+        /** Called by the node to send an RPC to a peer — must be wired up externally */
+        this.sendMessage = () => { };
+        this.eventListeners = {
+            leaderChanged: new Set(),
+            committed: new Set(),
+            roleChanged: new Set(),
+        };
+        this.destroyed = false;
+        this.id = id;
+        this.log = log;
+        this.electionTimeoutMin = (_a = options === null || options === void 0 ? void 0 : options.electionTimeoutMin) !== null && _a !== void 0 ? _a : 2000;
+        this.electionTimeoutMax = (_b = options === null || options === void 0 ? void 0 : options.electionTimeoutMax) !== null && _b !== void 0 ? _b : 4000;
+        this.heartbeatInterval = (_c = options === null || options === void 0 ? void 0 : options.heartbeatInterval) !== null && _c !== void 0 ? _c : 400;
+        // Restore persistent state
+        const state = this.log.loadState();
+        this.currentTerm = state.currentTerm;
+        this.votedFor = state.votedFor;
+    }
+    // --- Public API ---
+    /** Start the node (begin election timer as follower) */
+    start(peerIds) {
+        this.peers = peerIds.filter((p) => p !== this.id);
+        this.resetElectionTimer();
+    }
+    /** Update the cluster membership dynamically (e.g. when peers join/leave) */
+    updatePeers(peerIds) {
+        this.peers = peerIds.filter((p) => p !== this.id);
+        // Reinitialize leader volatile state for new peers
+        if (this.role === 'leader') {
+            for (const peer of this.peers) {
+                if (!this.nextIndex.has(peer)) {
+                    this.nextIndex.set(peer, this.log.lastIndex() + 1);
+                    this.matchIndex.set(peer, 0);
+                }
+            }
+        }
+    }
+    /** Submit a command to be replicated. Only succeeds on the leader. */
+    propose(command) {
+        if (this.role !== 'leader') {
+            return false;
+        }
+        const entry = { term: this.currentTerm, command };
+        this.log.append([entry]);
+        this.persistState();
+        // Immediately replicate to followers
+        this.sendAppendEntriesToAll();
+        // Check if we can commit (single-node cluster)
+        this.advanceCommitIndex();
+        return true;
+    }
+    /** Handle an incoming Raft RPC message from a peer */
+    handleMessage(fromPeerId, message) {
+        if (this.destroyed)
+            return;
+        // If we see a higher term, step down
+        const msgTerm = 'term' in message ? message.term : 0;
+        if (msgTerm > this.currentTerm) {
+            this.currentTerm = msgTerm;
+            this.votedFor = null;
+            this.persistState();
+            this.becomeFollower();
+        }
+        switch (message.type) {
+            case 'RequestVote':
+                this.handleRequestVote(fromPeerId, message);
+                break;
+            case 'RequestVoteResult':
+                this.handleRequestVoteResult(fromPeerId, message);
+                break;
+            case 'AppendEntries':
+                this.handleAppendEntries(fromPeerId, message);
+                break;
+            case 'AppendEntriesResult':
+                this.handleAppendEntriesResult(message);
+                break;
+        }
+    }
+    /** Get current role */
+    getRole() {
+        return this.role;
+    }
+    /** Get current term */
+    getCurrentTerm() {
+        return this.currentTerm;
+    }
+    /** Get the current leader ID (null if unknown) */
+    getLeaderId() {
+        return this.leaderId;
+    }
+    /** Get the commit index */
+    getCommitIndex() {
+        return this.commitIndex;
+    }
+    /** Check if this node is the leader */
+    isLeader() {
+        return this.role === 'leader';
+    }
+    /** Register an event listener */
+    on(event, listener) {
+        this.eventListeners[event].add(listener);
+    }
+    /** Remove an event listener */
+    off(event, listener) {
+        this.eventListeners[event].delete(listener);
+    }
+    /** Stop all timers and clean up */
+    destroy() {
+        this.destroyed = true;
+        this.clearElectionTimer();
+        this.clearHeartbeatTimer();
+    }
+    // --- Election ---
+    becomeFollower() {
+        const wasLeader = this.role === 'leader';
+        this.role = 'follower';
+        this.clearHeartbeatTimer();
+        this.resetElectionTimer();
+        this.emit('roleChanged', 'follower');
+        if (wasLeader) {
+            // Leader identity is unknown until we hear from the new leader
+        }
+    }
+    becomeCandidate() {
+        this.role = 'candidate';
+        this.currentTerm++;
+        this.votedFor = this.id;
+        this.persistState();
+        this.votesReceived.clear();
+        this.votesReceived.add(this.id); // vote for self
+        this.leaderId = null;
+        this.emit('roleChanged', 'candidate');
+        this.emit('leaderChanged', null);
+        this.resetElectionTimer();
+        // Single-node cluster: become leader immediately
+        if (this.peers.length === 0) {
+            this.becomeLeader();
+            return;
+        }
+        // Send RequestVote to all peers
+        const request = {
+            type: 'RequestVote',
+            term: this.currentTerm,
+            candidateId: this.id,
+            lastLogIndex: this.log.lastIndex(),
+            lastLogTerm: this.log.lastTerm(),
+        };
+        for (const peer of this.peers) {
+            this.sendMessage(peer, request);
+        }
+    }
+    becomeLeader() {
+        this.role = 'leader';
+        this.leaderId = this.id;
+        this.clearElectionTimer();
+        this.emit('roleChanged', 'leader');
+        this.emit('leaderChanged', this.id);
+        // Initialize nextIndex and matchIndex for all peers
+        const lastLogIndex = this.log.lastIndex();
+        this.nextIndex.clear();
+        this.matchIndex.clear();
+        for (const peer of this.peers) {
+            this.nextIndex.set(peer, lastLogIndex + 1);
+            this.matchIndex.set(peer, 0);
+        }
+        // Send initial heartbeats
+        this.sendAppendEntriesToAll();
+        // Start heartbeat timer
+        this.clearHeartbeatTimer();
+        this.heartbeatTimer = setInterval(() => {
+            if (this.role === 'leader' && !this.destroyed) {
+                this.sendAppendEntriesToAll();
+            }
+        }, this.heartbeatInterval);
+    }
+    // --- RequestVote handling ---
+    handleRequestVote(_fromPeerId, args) {
+        const reply = {
+            type: 'RequestVoteResult',
+            term: this.currentTerm,
+            voteGranted: false,
+        };
+        // Reject if candidate's term is behind
+        if (args.term < this.currentTerm) {
+            this.sendMessage(args.candidateId, reply);
+            return;
+        }
+        // Grant vote if we haven't voted for someone else, and candidate's log is up-to-date
+        const canVote = this.votedFor === null || this.votedFor === args.candidateId;
+        const candidateLogUpToDate = this.isLogUpToDate(args.lastLogTerm, args.lastLogIndex);
+        if (canVote && candidateLogUpToDate) {
+            this.votedFor = args.candidateId;
+            this.persistState();
+            reply.voteGranted = true;
+            this.resetElectionTimer(); // reset timer on granting vote
+        }
+        this.sendMessage(args.candidateId, reply);
+    }
+    handleRequestVoteResult(fromPeerId, result) {
+        if (this.role !== 'candidate')
+            return;
+        if (result.term !== this.currentTerm)
+            return;
+        if (result.voteGranted) {
+            this.votesReceived.add(fromPeerId);
+            // Check majority (votesReceived includes self)
+            const totalCluster = this.peers.length + 1;
+            if (this.votesReceived.size >= Math.floor(totalCluster / 2) + 1) {
+                this.becomeLeader();
+            }
+        }
+    }
+    /** Check if a candidate's log is at least as up-to-date as ours */
+    isLogUpToDate(candidateLastTerm, candidateLastIndex) {
+        const myLastTerm = this.log.lastTerm();
+        if (candidateLastTerm !== myLastTerm) {
+            return candidateLastTerm > myLastTerm;
+        }
+        return candidateLastIndex >= this.log.lastIndex();
+    }
+    // --- AppendEntries handling ---
+    handleAppendEntries(_fromPeerId, args) {
+        const reply = {
+            type: 'AppendEntriesResult',
+            term: this.currentTerm,
+            success: false,
+            responderId: this.id,
+            matchIndex: 0,
+        };
+        // Reject if leader's term is behind
+        if (args.term < this.currentTerm) {
+            this.sendMessage(args.leaderId, reply);
+            return;
+        }
+        // Valid leader — become follower if not already
+        if (this.role !== 'follower') {
+            this.becomeFollower();
+        }
+        else {
+            this.resetElectionTimer();
+        }
+        if (this.leaderId !== args.leaderId) {
+            this.leaderId = args.leaderId;
+            this.emit('leaderChanged', args.leaderId);
+        }
+        // Check log consistency
+        if (args.prevLogIndex > 0) {
+            const prevTerm = this.log.getTerm(args.prevLogIndex);
+            if (prevTerm === 0 && args.prevLogIndex > this.log.lastIndex()) {
+                // We don't have an entry at prevLogIndex
+                this.resetElectionTimer();
+                this.sendMessage(args.leaderId, reply);
+                return;
+            }
+            if (prevTerm !== args.prevLogTerm) {
+                // Conflict: delete this entry and everything after
+                this.log.truncateFrom(args.prevLogIndex);
+                this.resetElectionTimer();
+                this.sendMessage(args.leaderId, reply);
+                return;
+            }
+        }
+        // Append new entries (handle conflicts and skip duplicates)
+        if (args.entries.length > 0) {
+            for (let i = 0; i < args.entries.length; i++) {
+                const entryIndex = args.prevLogIndex + 1 + i;
+                const existing = this.log.getEntry(entryIndex);
+                if (existing) {
+                    if (existing.term !== args.entries[i].term) {
+                        // Conflict: truncate from here and append the rest
+                        this.log.truncateFrom(entryIndex);
+                        this.log.append(args.entries.slice(i));
+                        break;
+                    }
+                    // Same term — entry already present, skip
+                }
+                else {
+                    // No existing entry — append remaining
+                    this.log.append(args.entries.slice(i));
+                    break;
+                }
+            }
+        }
+        // Update commit index
+        if (args.leaderCommit > this.commitIndex) {
+            this.commitIndex = Math.min(args.leaderCommit, this.log.lastIndex());
+            this.applyCommitted();
+        }
+        reply.success = true;
+        reply.matchIndex = args.prevLogIndex + args.entries.length;
+        this.resetElectionTimer();
+        this.sendMessage(args.leaderId, reply);
+    }
+    handleAppendEntriesResult(result) {
+        var _a;
+        if (this.role !== 'leader')
+            return;
+        if (result.term !== this.currentTerm)
+            return;
+        const peer = result.responderId;
+        if (result.success) {
+            // Update nextIndex and matchIndex
+            if (result.matchIndex > 0) {
+                this.nextIndex.set(peer, result.matchIndex + 1);
+                this.matchIndex.set(peer, result.matchIndex);
+            }
+            this.advanceCommitIndex();
+        }
+        else {
+            // Decrement nextIndex and retry
+            const ni = (_a = this.nextIndex.get(peer)) !== null && _a !== void 0 ? _a : 1;
+            this.nextIndex.set(peer, Math.max(1, ni - 1));
+            this.sendAppendEntriesTo(peer);
+        }
+    }
+    // --- Log replication ---
+    sendAppendEntriesToAll() {
+        for (const peer of this.peers) {
+            this.sendAppendEntriesTo(peer);
+        }
+    }
+    sendAppendEntriesTo(peer) {
+        var _a;
+        const ni = (_a = this.nextIndex.get(peer)) !== null && _a !== void 0 ? _a : this.log.lastIndex() + 1;
+        const prevLogIndex = ni - 1;
+        const prevLogTerm = this.log.getTerm(prevLogIndex);
+        const lastIndex = this.log.lastIndex();
+        const entries = ni <= lastIndex ? this.log.getEntries(ni, lastIndex) : [];
+        const args = {
+            type: 'AppendEntries',
+            term: this.currentTerm,
+            leaderId: this.id,
+            prevLogIndex,
+            prevLogTerm,
+            entries,
+            leaderCommit: this.commitIndex,
+        };
+        this.sendMessage(peer, args);
+    }
+    /** Advance commitIndex if a majority of matchIndex values allow it */
+    advanceCommitIndex() {
+        var _a;
+        const lastIndex = this.log.lastIndex();
+        for (let n = lastIndex; n > this.commitIndex; n--) {
+            // Only commit entries from the current term
+            if (this.log.getTerm(n) !== this.currentTerm)
+                continue;
+            // Count replicas (including self)
+            let replicaCount = 1; // self
+            for (const peer of this.peers) {
+                if (((_a = this.matchIndex.get(peer)) !== null && _a !== void 0 ? _a : 0) >= n) {
+                    replicaCount++;
+                }
+            }
+            const majority = Math.floor((this.peers.length + 1) / 2) + 1;
+            if (replicaCount >= majority) {
+                this.commitIndex = n;
+                this.applyCommitted();
+                break;
+            }
+        }
+    }
+    /** Apply all committed but not-yet-applied entries */
+    applyCommitted() {
+        while (this.lastApplied < this.commitIndex) {
+            this.lastApplied++;
+            const entry = this.log.getEntry(this.lastApplied);
+            if (entry) {
+                this.emit('committed', entry, this.lastApplied);
+            }
+        }
+    }
+    // --- Timer management ---
+    resetElectionTimer() {
+        this.clearElectionTimer();
+        const timeout = this.electionTimeoutMin +
+            Math.random() * (this.electionTimeoutMax - this.electionTimeoutMin);
+        this.electionTimer = setTimeout(() => {
+            if (!this.destroyed) {
+                this.becomeCandidate();
+            }
+        }, timeout);
+    }
+    clearElectionTimer() {
+        if (this.electionTimer !== null) {
+            clearTimeout(this.electionTimer);
+            this.electionTimer = null;
+        }
+    }
+    clearHeartbeatTimer() {
+        if (this.heartbeatTimer !== null) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+    }
+    // --- Persistence ---
+    persistState() {
+        this.log.saveState({
+            currentTerm: this.currentTerm,
+            votedFor: this.votedFor,
+        });
+    }
+    // --- Event emission ---
+    emit(event, ...args) {
+        for (const listener of this.eventListeners[event]) {
+            listener(...args);
+        }
+    }
+}
+exports.RaftNode = RaftNode;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"RaftNode.js","sourceRoot":"","sources":["../../../src/raft/RaftNode.ts"],"names":[],"mappings":"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"}

package/build/main/raft/log/InMemoryRaftLog.d.ts

@@ -0,0 +1,20 @@
+import { LogEntry, RaftPersistentState } from '../types';
+import { RaftLog } from './RaftLog';
+/**
+ * In-memory Raft log implementation.
+ * All state is lost on page refresh — suitable for ephemeral sessions.
+ */
+export declare class InMemoryRaftLog<T = unknown> implements RaftLog<T> {
+    private entries;
+    private state;
+    loadState(): RaftPersistentState;
+    saveState(state: RaftPersistentState): void;
+    length(): number;
+    getEntry(index: number): LogEntry<T> | undefined;
+    getTerm(index: number): number;
+    append(entries: LogEntry<T>[]): void;
+    truncateFrom(index: number): void;
+    getEntries(startIndex: number, endIndex: number): LogEntry<T>[];
+    lastIndex(): number;
+    lastTerm(): number;
+}

package/build/main/raft/log/InMemoryRaftLog.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryRaftLog = void 0;
+/**
+ * In-memory Raft log implementation.
+ * All state is lost on page refresh — suitable for ephemeral sessions.
+ */
+class InMemoryRaftLog {
+    constructor() {
+        this.entries = [];
+        this.state = { currentTerm: 0, votedFor: null };
+    }
+    loadState() {
+        return Object.assign({}, this.state);
+    }
+    saveState(state) {
+        this.state = Object.assign({}, state);
+    }
+    length() {
+        return this.entries.length;
+    }
+    getEntry(index) {
+        if (index < 1 || index > this.entries.length) {
+            return undefined;
+        }
+        return this.entries[index - 1];
+    }
+    getTerm(index) {
+        var _a, _b;
+        return (_b = (_a = this.getEntry(index)) === null || _a === void 0 ? void 0 : _a.term) !== null && _b !== void 0 ? _b : 0;
+    }
+    append(entries) {
+        this.entries.push(...entries);
+    }
+    truncateFrom(index) {
+        if (index < 1)
+            return;
+        this.entries.length = index - 1;
+    }
+    getEntries(startIndex, endIndex) {
+        if (startIndex > endIndex || startIndex > this.entries.length)
+            return [];
+        return this.entries.slice(startIndex - 1, endIndex);
+    }
+    lastIndex() {
+        return this.entries.length;
+    }
+    lastTerm() {
+        if (this.entries.length === 0)
+            return 0;
+        return this.entries[this.entries.length - 1].term;
+    }
+}
+exports.InMemoryRaftLog = InMemoryRaftLog;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSW5NZW1vcnlSYWZ0TG9nLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3JhZnQvbG9nL0luTWVtb3J5UmFmdExvZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFJQTs7O0dBR0c7QUFDSCxNQUFhLGVBQWU7SUFBNUI7UUFDVSxZQUFPLEdBQWtCLEVBQUUsQ0FBQztRQUM1QixVQUFLLEdBQXdCLEVBQUUsV0FBVyxFQUFFLENBQUMsRUFBRSxRQUFRLEVBQUUsSUFBSSxFQUFFLENBQUM7SUErQzFFLENBQUM7SUE3Q0MsU0FBUztRQUNQLHlCQUFZLElBQUksQ0FBQyxLQUFLLEVBQUc7SUFDM0IsQ0FBQztJQUVELFNBQVMsQ0FBQyxLQUEwQjtRQUNsQyxJQUFJLENBQUMsS0FBSyxxQkFBUSxLQUFLLENBQUUsQ0FBQztJQUM1QixDQUFDO0lBRUQsTUFBTTtRQUNKLE9BQU8sSUFBSSxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUM7SUFDN0IsQ0FBQztJQUVELFFBQVEsQ0FBQyxLQUFhO1FBQ3BCLElBQUksS0FBSyxHQUFHLENBQUMsSUFBSSxLQUFLLEdBQUcsSUFBSSxDQUFDLE9BQU8sQ0FBQyxNQUFNLEVBQUU7WUFDNUMsT0FBTyxTQUFTLENBQUM7U0FDbEI7UUFDRCxPQUFPLElBQUksQ0FBQyxPQUFPLENBQUMsS0FBSyxHQUFHLENBQUMsQ0FBQyxDQUFDO0lBQ2pDLENBQUM7SUFFRCxPQUFPLENBQUMsS0FBYTs7UUFDbkIsT0FBTyxNQUFBLE1BQUEsSUFBSSxDQUFDLFFBQVEsQ0FBQyxLQUFLLENBQUMsMENBQUUsSUFBSSxtQ0FBSSxDQUFDLENBQUM7SUFDekMsQ0FBQztJQUVELE1BQU0sQ0FBQyxPQUFzQjtRQUMzQixJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxHQUFHLE9BQU8sQ0FBQyxDQUFDO0lBQ2hDLENBQUM7SUFFRCxZQUFZLENBQUMsS0FBYTtRQUN4QixJQUFJLEtBQUssR0FBRyxDQUFDO1lBQUUsT0FBTztRQUN0QixJQUFJLENBQUMsT0FBTyxDQUFDLE1BQU0sR0FBRyxLQUFLLEdBQUcsQ0FBQyxDQUFDO0lBQ2xDLENBQUM7SUFFRCxVQUFVLENBQUMsVUFBa0IsRUFBRSxRQUFnQjtRQUM3QyxJQUFJLFVBQVUsR0FBRyxRQUFRLElBQUksVUFBVSxHQUFHLElBQUksQ0FBQyxPQUFPLENBQUMsTUFBTTtZQUFFLE9BQU8sRUFBRSxDQUFDO1FBQ3pFLE9BQU8sSUFBSSxDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsVUFBVSxHQUFHLENBQUMsRUFBRSxRQUFRLENBQUMsQ0FBQztJQUN0RCxDQUFDO0lBRUQsU0FBUztRQUNQLE9BQU8sSUFBSSxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUM7SUFDN0IsQ0FBQztJQUVELFFBQVE7UUFDTixJQUFJLElBQUksQ0FBQyxPQUFPLENBQUMsTUFBTSxLQUFLLENBQUM7WUFBRSxPQUFPLENBQUMsQ0FBQztRQUN4QyxPQUFPLElBQUksQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxNQUFNLEdBQUcsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDO0lBQ3BELENBQUM7Q0FDRjtBQWpERCwwQ0FpREMifQ==

package/build/main/raft/log/LocalStorageRaftLog.d.ts

@@ -0,0 +1,9 @@
+import { StorageRaftLog } from './StorageRaftLog';
+/**
+ * localStorage-backed Raft log implementation.
+ * Survives page refreshes — suitable for durable sessions where peers
+ * may rejoin after a restart.
+ */
+export declare class LocalStorageRaftLog<T = unknown> extends StorageRaftLog<T> {
+    constructor(namespace: string);
+}

package/build/main/raft/log/LocalStorageRaftLog.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalStorageRaftLog = void 0;
+const StorageRaftLog_1 = require("./StorageRaftLog");
+/**
+ * localStorage-backed Raft log implementation.
+ * Survives page refreshes — suitable for durable sessions where peers
+ * may rejoin after a restart.
+ */
+class LocalStorageRaftLog extends StorageRaftLog_1.StorageRaftLog {
+    constructor(namespace) {
+        super(localStorage, namespace);
+    }
+}
+exports.LocalStorageRaftLog = LocalStorageRaftLog;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTG9jYWxTdG9yYWdlUmFmdExvZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9yYWZ0L2xvZy9Mb2NhbFN0b3JhZ2VSYWZ0TG9nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLHFEQUFrRDtBQUVsRDs7OztHQUlHO0FBQ0gsTUFBYSxtQkFBaUMsU0FBUSwrQkFBaUI7SUFDckUsWUFBWSxTQUFpQjtRQUMzQixLQUFLLENBQUMsWUFBWSxFQUFFLFNBQVMsQ0FBQyxDQUFDO0lBQ2pDLENBQUM7Q0FDRjtBQUpELGtEQUlDIn0=

package/build/main/raft/log/RaftLog.d.ts

@@ -0,0 +1,30 @@
+import { LogEntry, RaftPersistentState } from '../types';
+/**
+ * Abstract log persistence interface for the Raft consensus algorithm.
+ * Raft log indices are 1-based.
+ */
+export interface RaftLog<T = unknown> {
+    /** Load persistent state (currentTerm, votedFor). Returns defaults if not yet stored. */
+    loadState(): RaftPersistentState;
+    /** Persist the current term and votedFor */
+    saveState(state: RaftPersistentState): void;
+    /** Number of entries in the log */
+    length(): number;
+    /** Get the entry at the given 1-based index, or undefined if out of range */
+    getEntry(index: number): LogEntry<T> | undefined;
+    /** Get the term of the entry at the given 1-based index, or 0 if out of range */
+    getTerm(index: number): number;
+    /** Append one or more entries to the end of the log */
+    append(entries: LogEntry<T>[]): void;
+    /**
+     * Delete all entries from the given 1-based index onward (inclusive).
+     * Used when resolving log conflicts.
+     */
+    truncateFrom(index: number): void;
+    /** Get all entries from startIndex to endIndex (both inclusive, 1-based) */
+    getEntries(startIndex: number, endIndex: number): LogEntry<T>[];
+    /** Get the index of the last entry (0 if log is empty) */
+    lastIndex(): number;
+    /** Get the term of the last entry (0 if log is empty) */
+    lastTerm(): number;
+}

package/build/main/raft/log/RaftLog.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmFmdExvZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9yYWZ0L2xvZy9SYWZ0TG9nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/build/main/raft/log/RaftLog.test-util.d.ts

@@ -0,0 +1,3 @@
+import { ExecutionContext } from 'ava';
+import { RaftLog } from './RaftLog';
+export declare function runCommonRaftLogTests<T>(t: ExecutionContext, createLog: () => RaftLog<T>): void;