dandelion-mesh 1.0.0

package/build/module/mesh/types.d.ts

@@ -0,0 +1,58 @@
+import { EncryptedPayload } from '../crypto/CryptoService';
+export interface PublicMessage<T = unknown> {
+    type: 'public';
+    sender: string;
+    data: T;
+}
+export interface PrivateMessage<T = unknown> {
+    type: 'private';
+    sender: string;
+    recipient: string;
+    data: T;
+}
+export type MeshMessage<T = unknown> = PublicMessage<T> | PrivateMessage<T>;
+/** Broadcast of a peer's RSA public key */
+export interface PublicKeyAnnouncement {
+    _meshType: 'publicKey';
+    peerId: string;
+    jwk: JsonWebKey;
+}
+/** An encrypted private message (the Raft log entry payload for private messages) */
+export interface EncryptedPrivateMessage {
+    _meshType: 'encrypted';
+    sender: string;
+    recipient: string;
+    payload: EncryptedPayload;
+}
+/** A public message log entry */
+export interface PublicMessageEntry<T = unknown> {
+    _meshType: 'public';
+    sender: string;
+    data: T;
+}
+/** Union of all Raft log command types */
+export type MeshLogCommand<T = unknown> = PublicMessageEntry<T> | EncryptedPrivateMessage | PublicKeyAnnouncement;
+/** A proposal forwarded from a non-leader to the leader */
+export interface ProposeMessage<T = unknown> {
+    _meshType: 'propose';
+    command: MeshLogCommand<T>;
+}
+/** Internal transport-level messages (not replicated via Raft) */
+export type MeshControlMessage<T = unknown> = ProposeMessage<T>;
+/** Wrapper to distinguish Raft messages from mesh control messages on the wire */
+export interface WireMessage {
+    channel: 'raft' | 'control';
+    payload: unknown;
+}
+export interface DandelionMeshEvents<T = unknown> {
+    /** Local peer is ready */
+    ready: (localPeerId: string) => void;
+    /** A message was committed and delivered */
+    message: (message: MeshMessage<T>, replay: boolean) => void;
+    /** The set of connected peer IDs changed */
+    peersChanged: (peers: string[]) => void;
+    /** The cluster leader changed */
+    leaderChanged: (leaderId: string | null) => void;
+    /** An error occurred */
+    error: (error: Error) => void;
+}

package/build/module/mesh/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbWVzaC90eXBlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/build/module/raft/RaftNode.d.ts

@@ -0,0 +1,87 @@
+import { RaftLog } from './log/RaftLog';
+import { RaftMessage, RaftNodeEvents, RaftRole } from './types';
+export interface RaftNodeOptions {
+    /** Minimum election timeout in ms (default 2000) */
+    electionTimeoutMin?: number;
+    /** Maximum election timeout in ms (default 4000) */
+    electionTimeoutMax?: number;
+    /** Heartbeat interval in ms (default 400) */
+    heartbeatInterval?: number;
+}
+/**
+ * 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.
+ */
+export declare class RaftNode<T = unknown> {
+    readonly id: string;
+    private role;
+    private currentTerm;
+    private votedFor;
+    private leaderId;
+    private commitIndex;
+    private lastApplied;
+    private nextIndex;
+    private matchIndex;
+    private electionTimer;
+    private heartbeatTimer;
+    private readonly electionTimeoutMin;
+    private readonly electionTimeoutMax;
+    private readonly heartbeatInterval;
+    private peers;
+    private votesReceived;
+    private readonly log;
+    /** Called by the node to send an RPC to a peer — must be wired up externally */
+    sendMessage: (toPeerId: string, message: RaftMessage<T>) => void;
+    private readonly eventListeners;
+    private destroyed;
+    constructor(id: string, log: RaftLog<T>, options?: RaftNodeOptions);
+    /** Start the node (begin election timer as follower) */
+    start(peerIds: string[]): void;
+    /** Update the cluster membership dynamically (e.g. when peers join/leave) */
+    updatePeers(peerIds: string[]): void;
+    /** Submit a command to be replicated. Only succeeds on the leader. */
+    propose(command: T): boolean;
+    /** Handle an incoming Raft RPC message from a peer */
+    handleMessage(fromPeerId: string, message: RaftMessage<T>): void;
+    /** Get current role */
+    getRole(): RaftRole;
+    /** Get current term */
+    getCurrentTerm(): number;
+    /** Get the current leader ID (null if unknown) */
+    getLeaderId(): string | null;
+    /** Get the commit index */
+    getCommitIndex(): number;
+    /** Check if this node is the leader */
+    isLeader(): boolean;
+    /** Register an event listener */
+    on<E extends keyof RaftNodeEvents<T>>(event: E, listener: RaftNodeEvents<T>[E]): void;
+    /** Remove an event listener */
+    off<E extends keyof RaftNodeEvents<T>>(event: E, listener: RaftNodeEvents<T>[E]): void;
+    /** Stop all timers and clean up */
+    destroy(): void;
+    private becomeFollower;
+    private becomeCandidate;
+    private becomeLeader;
+    private handleRequestVote;
+    private handleRequestVoteResult;
+    /** Check if a candidate's log is at least as up-to-date as ours */
+    private isLogUpToDate;
+    private handleAppendEntries;
+    private handleAppendEntriesResult;
+    private sendAppendEntriesToAll;
+    private sendAppendEntriesTo;
+    /** Advance commitIndex if a majority of matchIndex values allow it */
+    private advanceCommitIndex;
+    /** Apply all committed but not-yet-applied entries */
+    private applyCommitted;
+    private resetElectionTimer;
+    private clearElectionTimer;
+    private clearHeartbeatTimer;
+    private persistState;
+    private emit;
+}

package/build/module/raft/RaftNode.js

@@ -0,0 +1,440 @@
+/**
+ * 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.
+ */
+export class RaftNode {
+    id;
+    role = 'follower';
+    currentTerm = 0;
+    votedFor = null;
+    leaderId = null;
+    // Volatile state (all servers)
+    commitIndex = 0;
+    lastApplied = 0;
+    // Volatile state (leader only)
+    nextIndex = new Map();
+    matchIndex = new Map();
+    // Election / heartbeat timers
+    electionTimer = null;
+    heartbeatTimer = null;
+    electionTimeoutMin;
+    electionTimeoutMax;
+    heartbeatInterval;
+    // Cluster membership (peer IDs excluding self)
+    peers = [];
+    // Votes received in current election
+    votesReceived = new Set();
+    log;
+    /** Called by the node to send an RPC to a peer — must be wired up externally */
+    sendMessage = () => { };
+    eventListeners = {
+        leaderChanged: new Set(),
+        committed: new Set(),
+        roleChanged: new Set(),
+    };
+    destroyed = false;
+    constructor(id, log, options) {
+        this.id = id;
+        this.log = log;
+        this.electionTimeoutMin = options?.electionTimeoutMin ?? 2000;
+        this.electionTimeoutMax = options?.electionTimeoutMax ?? 4000;
+        this.heartbeatInterval = options?.heartbeatInterval ?? 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) {
+        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 = this.nextIndex.get(peer) ?? 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) {
+        const ni = this.nextIndex.get(peer) ?? 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() {
+        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 ((this.matchIndex.get(peer) ?? 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);
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"RaftNode.js","sourceRoot":"","sources":["../../../src/raft/RaftNode.ts"],"names":[],"mappings":"AAyBA;;;;;;;;GAQG;AACH,MAAM,OAAO,QAAQ;IACV,EAAE,CAAS;IAEZ,IAAI,GAAa,UAAU,CAAC;IAC5B,WAAW,GAAG,CAAC,CAAC;IAChB,QAAQ,GAAkB,IAAI,CAAC;IAC/B,QAAQ,GAAkB,IAAI,CAAC;IAEvC,+BAA+B;IACvB,WAAW,GAAG,CAAC,CAAC;IAChB,WAAW,GAAG,CAAC,CAAC;IAExB,+BAA+B;IACvB,SAAS,GAAG,IAAI,GAAG,EAAkB,CAAC;IACtC,UAAU,GAAG,IAAI,GAAG,EAAkB,CAAC;IAE/C,8BAA8B;IACtB,aAAa,GAAyC,IAAI,CAAC;IAC3D,cAAc,GAA0C,IAAI,CAAC;IAEpD,kBAAkB,CAAS;IAC3B,kBAAkB,CAAS;IAC3B,iBAAiB,CAAS;IAE3C,+CAA+C;IACvC,KAAK,GAAa,EAAE,CAAC;IAE7B,qCAAqC;IAC7B,aAAa,GAAG,IAAI,GAAG,EAAU,CAAC;IAEzB,GAAG,CAAa;IAEjC,gFAAgF;IACzE,WAAW,GAChB,GAAG,EAAE,GAAE,CAAC,CAAC;IAEM,cAAc,GAAwB;QACrD,aAAa,EAAE,IAAI,GAAG,EAAE;QACxB,SAAS,EAAE,IAAI,GAAG,EAAE;QACpB,WAAW,EAAE,IAAI,GAAG,EAAE;KACvB,CAAC;IAEM,SAAS,GAAG,KAAK,CAAC;IAE1B,YAAY,EAAU,EAAE,GAAe,EAAE,OAAyB;QAChE,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;QACb,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;QAEf,IAAI,CAAC,kBAAkB,GAAG,OAAO,EAAE,kBAAkB,IAAI,IAAI,CAAC;QAC9D,IAAI,CAAC,kBAAkB,GAAG,OAAO,EAAE,kBAAkB,IAAI,IAAI,CAAC;QAC9D,IAAI,CAAC,iBAAiB,GAAG,OAAO,EAAE,iBAAiB,IAAI,GAAG,CAAC;QAE3D,2BAA2B;QAC3B,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,CAAC;QACnC,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC,WAAW,CAAC;QACrC,IAAI,CAAC,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAAC;IACjC,CAAC;IAED,qBAAqB;IAErB,wDAAwD;IACxD,KAAK,CAAC,OAAiB;QACrB,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,IAAI,CAAC,EAAE,CAAC,CAAC;QAClD,IAAI,CAAC,kBAAkB,EAAE,CAAC;IAC5B,CAAC;IAED,6EAA6E;IAC7E,WAAW,CAAC,OAAiB;QAC3B,IAAI,CAAC,KAAK,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,IAAI,CAAC,EAAE,CAAC,CAAC;QAClD,mDAAmD;QACnD,IAAI,IAAI,CAAC,IAAI,KAAK,QAAQ,EAAE;YAC1B,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,KAAK,EAAE;gBAC7B,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE;oBAC7B,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC,CAAC;oBACnD,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;iBAC9B;aACF;SACF;IACH,CAAC;IAED,sEAAsE;IACtE,OAAO,CAAC,OAAU;QAChB,IAAI,IAAI,CAAC,IAAI,KAAK,QAAQ,EAAE;YAC1B,OAAO,KAAK,CAAC;SACd;QACD,MAAM,KAAK,GAAgB,EAAE,IAAI,EAAE,IAAI,CAAC,WAAW,EAAE,OAAO,EAAE,CAAC;QAC/D,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;QACzB,IAAI,CAAC,YAAY,EAAE,CAAC;QAEpB,qCAAqC;QACrC,IAAI,CAAC,sBAAsB,EAAE,CAAC;QAE9B,+CAA+C;QAC/C,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAC1B,OAAO,IAAI,CAAC;IACd,CAAC;IAED,sDAAsD;IACtD,aAAa,CAAC,UAAkB,EAAE,OAAuB;QACvD,IAAI,IAAI,CAAC,SAAS;YAAE,OAAO;QAE3B,qCAAqC;QACrC,MAAM,OAAO,GAAG,MAAM,IAAI,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;QACrD,IAAI,OAAO,GAAG,IAAI,CAAC,WAAW,EAAE;YAC9B,IAAI,CAAC,WAAW,GAAG,OAAO,CAAC;YAC3B,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;YACrB,IAAI,CAAC,YAAY,EAAE,CAAC;YACpB,IAAI,CAAC,cAAc,EAAE,CAAC;SACvB;QAED,QAAQ,OAAO,CAAC,IAAI,EAAE;YACpB,KAAK,aAAa;gBAChB,IAAI,CAAC,iBAAiB,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;gBAC5C,MAAM;YACR,KAAK,mBAAmB;gBACtB,IAAI,CAAC,uBAAuB,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;gBAClD,MAAM;YACR,KAAK,eAAe;gBAClB,IAAI,CAAC,mBAAmB,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;gBAC9C,MAAM;YACR,KAAK,qBAAqB;gBACxB,IAAI,CAAC,yBAAyB,CAAC,OAAO,CAAC,CAAC;gBACxC,MAAM;SACT;IACH,CAAC;IAED,uBAAuB;IACvB,OAAO;QACL,OAAO,IAAI,CAAC,IAAI,CAAC;IACnB,CAAC;IAED,uBAAuB;IACvB,cAAc;QACZ,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IAED,kDAAkD;IAClD,WAAW;QACT,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAED,2BAA2B;IAC3B,cAAc;QACZ,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IAED,uCAAuC;IACvC,QAAQ;QACN,OAAO,IAAI,CAAC,IAAI,KAAK,QAAQ,CAAC;IAChC,CAAC;IAED,iCAAiC;IACjC,EAAE,CACA,KAAQ,EACR,QAA8B;QAE7B,IAAI,CAAC,cAAc,CAAC,KAAK,CAA+B,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IAC1E,CAAC;IAED,+BAA+B;IAC/B,GAAG,CACD,KAAQ,EACR,QAA8B;QAE7B,IAAI,CAAC,cAAc,CAAC,KAAK,CAA+B,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IAC7E,CAAC;IAED,mCAAmC;IACnC,OAAO;QACL,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC;QACtB,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAC1B,IAAI,CAAC,mBAAmB,EAAE,CAAC;IAC7B,CAAC;IAED,mBAAmB;IAEX,cAAc;QACpB,MAAM,SAAS,GAAG,IAAI,CAAC,IAAI,KAAK,QAAQ,CAAC;QACzC,IAAI,CAAC,IAAI,GAAG,UAAU,CAAC;QACvB,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC3B,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAC1B,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,UAAU,CAAC,CAAC;QACrC,IAAI,SAAS,EAAE;YACb,+DAA+D;SAChE;IACH,CAAC;IAEO,eAAe;QACrB,IAAI,CAAC,IAAI,GAAG,WAAW,CAAC;QACxB,IAAI,CAAC,WAAW,EAAE,CAAC;QACnB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,EAAE,CAAC;QACxB,IAAI,CAAC,YAAY,EAAE,CAAC;QACpB,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;QAC3B,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB;QACjD,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC;QACrB,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,WAAW,CAAC,CAAC;QACtC,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,IAAI,CAAC,CAAC;QACjC,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAE1B,iDAAiD;QACjD,IAAI,IAAI,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE;YAC3B,IAAI,CAAC,YAAY,EAAE,CAAC;YACpB,OAAO;SACR;QAED,gCAAgC;QAChC,MAAM,OAAO,GAAoB;YAC/B,IAAI,EAAE,aAAa;YACnB,IAAI,EAAE,IAAI,CAAC,WAAW;YACtB,WAAW,EAAE,IAAI,CAAC,EAAE;YACpB,YAAY,EAAE,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE;YAClC,WAAW,EAAE,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE;SACjC,CAAC;QACF,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,KAAK,EAAE;YAC7B,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;SACjC;IACH,CAAC;IAEO,YAAY;QAClB,IAAI,CAAC,IAAI,GAAG,QAAQ,CAAC;QACrB,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,EAAE,CAAC;QACxB,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAC1B,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,QAAQ,CAAC,CAAC;QACnC,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,IAAI,CAAC,EAAE,CAAC,CAAC;QAEpC,oDAAoD;QACpD,MAAM,YAAY,GAAG,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,CAAC;QAC1C,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC;QACvB,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC;QACxB,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,KAAK,EAAE;YAC7B,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,EAAE,YAAY,GAAG,CAAC,CAAC,CAAC;YAC3C,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;SAC9B;QAED,0BAA0B;QAC1B,IAAI,CAAC,sBAAsB,EAAE,CAAC;QAE9B,wBAAwB;QACxB,IAAI,CAAC,mBAAmB,EAAE,CAAC;QAC3B,IAAI,CAAC,cAAc,GAAG,WAAW,CAAC,GAAG,EAAE;YACrC,IAAI,IAAI,CAAC,IAAI,KAAK,QAAQ,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE;gBAC7C,IAAI,CAAC,sBAAsB,EAAE,CAAC;aAC/B;QACH,CAAC,EAAE,IAAI,CAAC,iBAAiB,CAAC,CAAC;IAC7B,CAAC;IAED,+BAA+B;IAEvB,iBAAiB,CAAC,WAAmB,EAAE,IAAqB;QAClE,MAAM,KAAK,GAAsB;YAC/B,IAAI,EAAE,mBAAmB;YACzB,IAAI,EAAE,IAAI,CAAC,WAAW;YACtB,WAAW,EAAE,KAAK;SACnB,CAAC;QAEF,uCAAuC;QACvC,IAAI,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,WAAW,EAAE;YAChC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;YAC1C,OAAO;SACR;QAED,qFAAqF;QACrF,MAAM,OAAO,GACX,IAAI,CAAC,QAAQ,KAAK,IAAI,IAAI,IAAI,CAAC,QAAQ,KAAK,IAAI,CAAC,WAAW,CAAC;QAC/D,MAAM,oBAAoB,GAAG,IAAI,CAAC,aAAa,CAC7C,IAAI,CAAC,WAAW,EAChB,IAAI,CAAC,YAAY,CAClB,CAAC;QAEF,IAAI,OAAO,IAAI,oBAAoB,EAAE;YACnC,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,WAAW,CAAC;YACjC,IAAI,CAAC,YAAY,EAAE,CAAC;YACpB,KAAK,CAAC,WAAW,GAAG,IAAI,CAAC;YACzB,IAAI,CAAC,kBAAkB,EAAE,CAAC,CAAC,+BAA+B;SAC3D;QAED,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;IAC5C,CAAC;IAEO,uBAAuB,CAC7B,UAAkB,EAClB,MAAyB;QAEzB,IAAI,IAAI,CAAC,IAAI,KAAK,WAAW;YAAE,OAAO;QACtC,IAAI,MAAM,CAAC,IAAI,KAAK,IAAI,CAAC,WAAW;YAAE,OAAO;QAE7C,IAAI,MAAM,CAAC,WAAW,EAAE;YACtB,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;YAEnC,+CAA+C;YAC/C,MAAM,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;YAC3C,IAAI,IAAI,CAAC,aAAa,CAAC,IAAI,IAAI,IAAI,CAAC,KAAK,CAAC,YAAY,GAAG,CAAC,CAAC,GAAG,CAAC,EAAE;gBAC/D,IAAI,CAAC,YAAY,EAAE,CAAC;aACrB;SACF;IACH,CAAC;IAED,mEAAmE;IAC3D,aAAa,CACnB,iBAAyB,EACzB,kBAA0B;QAE1B,MAAM,UAAU,GAAG,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC;QACvC,IAAI,iBAAiB,KAAK,UAAU,EAAE;YACpC,OAAO,iBAAiB,GAAG,UAAU,CAAC;SACvC;QACD,OAAO,kBAAkB,IAAI,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,CAAC;IACpD,CAAC;IAED,iCAAiC;IAEzB,mBAAmB,CACzB,WAAmB,EACnB,IAA0B;QAE1B,MAAM,KAAK,GAAwB;YACjC,IAAI,EAAE,qBAAqB;YAC3B,IAAI,EAAE,IAAI,CAAC,WAAW;YACtB,OAAO,EAAE,KAAK;YACd,WAAW,EAAE,IAAI,CAAC,EAAE;YACpB,UAAU,EAAE,CAAC;SACd,CAAC;QAEF,oCAAoC;QACpC,IAAI,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,WAAW,EAAE;YAChC,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;YACvC,OAAO;SACR;QAED,gDAAgD;QAChD,IAAI,IAAI,CAAC,IAAI,KAAK,UAAU,EAAE;YAC5B,IAAI,CAAC,cAAc,EAAE,CAAC;SACvB;aAAM;YACL,IAAI,CAAC,kBAAkB,EAAE,CAAC;SAC3B;QACD,IAAI,IAAI,CAAC,QAAQ,KAAK,IAAI,CAAC,QAAQ,EAAE;YACnC,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC;YAC9B,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;SAC3C;QAED,wBAAwB;QACxB,IAAI,IAAI,CAAC,YAAY,GAAG,CAAC,EAAE;YACzB,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;YACrD,IAAI,QAAQ,KAAK,CAAC,IAAI,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,EAAE;gBAC9D,yCAAyC;gBACzC,IAAI,CAAC,kBAAkB,EAAE,CAAC;gBAC1B,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;gBACvC,OAAO;aACR;YACD,IAAI,QAAQ,KAAK,IAAI,CAAC,WAAW,EAAE;gBACjC,mDAAmD;gBACnD,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;gBACzC,IAAI,CAAC,kBAAkB,EAAE,CAAC;gBAC1B,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;gBACvC,OAAO;aACR;SACF;QAED,4DAA4D;QAC5D,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE;YAC3B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;gBAC5C,MAAM,UAAU,GAAG,IAAI,CAAC,YAAY,GAAG,CAAC,GAAG,CAAC,CAAC;gBAC7C,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;gBAC/C,IAAI,QAAQ,EAAE;oBACZ,IAAI,QAAQ,CAAC,IAAI,KAAK,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE;wBAC1C,mDAAmD;wBACnD,IAAI,CAAC,GAAG,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC;wBAClC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;wBACvC,MAAM;qBACP;oBACD,0CAA0C;iBAC3C;qBAAM;oBACL,uCAAuC;oBACvC,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;oBACvC,MAAM;iBACP;aACF;SACF;QAED,sBAAsB;QACtB,IAAI,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,WAAW,EAAE;YACxC,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,YAAY,EAAE,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,CAAC,CAAC;YACrE,IAAI,CAAC,cAAc,EAAE,CAAC;SACvB;QAED,KAAK,CAAC,OAAO,GAAG,IAAI,CAAC;QACrB,KAAK,CAAC,UAAU,GAAG,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC;QAC3D,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAC1B,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;IACzC,CAAC;IAEO,yBAAyB,CAAC,MAA2B;QAC3D,IAAI,IAAI,CAAC,IAAI,KAAK,QAAQ;YAAE,OAAO;QACnC,IAAI,MAAM,CAAC,IAAI,KAAK,IAAI,CAAC,WAAW;YAAE,OAAO;QAE7C,MAAM,IAAI,GAAG,MAAM,CAAC,WAAW,CAAC;QAEhC,IAAI,MAAM,CAAC,OAAO,EAAE;YAClB,kCAAkC;YAClC,IAAI,MAAM,CAAC,UAAU,GAAG,CAAC,EAAE;gBACzB,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,UAAU,GAAG,CAAC,CAAC,CAAC;gBAChD,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,UAAU,CAAC,CAAC;aAC9C;YACD,IAAI,CAAC,kBAAkB,EAAE,CAAC;SAC3B;aAAM;YACL,gCAAgC;YAChC,MAAM,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACzC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;YAC9C,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC;SAChC;IACH,CAAC;IAED,0BAA0B;IAElB,sBAAsB;QAC5B,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,KAAK,EAAE;YAC7B,IAAI,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC;SAChC;IACH,CAAC;IAEO,mBAAmB,CAAC,IAAY;QACtC,MAAM,EAAE,GAAG,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC;QAChE,MAAM,YAAY,GAAG,EAAE,GAAG,CAAC,CAAC;QAC5B,MAAM,WAAW,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;QACnD,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,CAAC;QAEvC,MAAM,OAAO,GAAG,EAAE,IAAI,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QAE1E,MAAM,IAAI,GAAyB;YACjC,IAAI,EAAE,eAAe;YACrB,IAAI,EAAE,IAAI,CAAC,WAAW;YACtB,QAAQ,EAAE,IAAI,CAAC,EAAE;YACjB,YAAY;YACZ,WAAW;YACX,OAAO;YACP,YAAY,EAAE,IAAI,CAAC,WAAW;SAC/B,CAAC;QACF,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IAC/B,CAAC;IAED,sEAAsE;IAC9D,kBAAkB;QACxB,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,CAAC;QACvC,KAAK,IAAI,CAAC,GAAG,SAAS,EAAE,CAAC,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC,EAAE,EAAE;YACjD,4CAA4C;YAC5C,IAAI,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC,WAAW;gBAAE,SAAS;YAEvD,kCAAkC;YAClC,IAAI,YAAY,GAAG,CAAC,CAAC,CAAC,OAAO;YAC7B,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,KAAK,EAAE;gBAC7B,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,EAAE;oBACzC,YAAY,EAAE,CAAC;iBAChB;aACF;YAED,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;YAC7D,IAAI,YAAY,IAAI,QAAQ,EAAE;gBAC5B,IAAI,CAAC,WAAW,GAAG,CAAC,CAAC;gBACrB,IAAI,CAAC,cAAc,EAAE,CAAC;gBACtB,MAAM;aACP;SACF;IACH,CAAC;IAED,sDAAsD;IAC9C,cAAc;QACpB,OAAO,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,EAAE;YAC1C,IAAI,CAAC,WAAW,EAAE,CAAC;YACnB,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;YAClD,IAAI,KAAK,EAAE;gBACT,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,KAAK,EAAE,IAAI,CAAC,WAAW,CAAC,CAAC;aACjD;SACF;IACH,CAAC;IAED,2BAA2B;IAEnB,kBAAkB;QACxB,IAAI,CAAC,kBAAkB,EAAE,CAAC;QAC1B,MAAM,OAAO,GACX,IAAI,CAAC,kBAAkB;YACvB,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC,kBAAkB,CAAC,CAAC;QACtE,IAAI,CAAC,aAAa,GAAG,UAAU,CAAC,GAAG,EAAE;YACnC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE;gBACnB,IAAI,CAAC,eAAe,EAAE,CAAC;aACxB;QACH,CAAC,EAAE,OAAO,CAAC,CAAC;IACd,CAAC;IAEO,kBAAkB;QACxB,IAAI,IAAI,CAAC,aAAa,KAAK,IAAI,EAAE;YAC/B,YAAY,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;YACjC,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;SAC3B;IACH,CAAC;IAEO,mBAAmB;QACzB,IAAI,IAAI,CAAC,cAAc,KAAK,IAAI,EAAE;YAChC,aAAa,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;YACnC,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;SAC5B;IACH,CAAC;IAED,sBAAsB;IAEd,YAAY;QAClB,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC;YACjB,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,QAAQ,EAAE,IAAI,CAAC,QAAQ;SACxB,CAAC,CAAC;IACL,CAAC;IAED,yBAAyB;IAEjB,IAAI,CACV,KAAQ,EACR,GAAG,IAAsC;QAEzC,KAAK,MAAM,QAAQ,IAAI,IAAI,CAAC,cAAc,CAAC,KAAK,CAAC,EAAE;YAChD,QAA6D,CAAC,GAAG,IAAI,CAAC,CAAC;SACzE;IACH,CAAC;CACF"}

package/build/module/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;
+}