dandelion-mesh 1.0.0

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

@@ -0,0 +1,48 @@
+/**
+ * In-memory Raft log implementation.
+ * All state is lost on page refresh — suitable for ephemeral sessions.
+ */
+export class InMemoryRaftLog {
+    entries = [];
+    state = { currentTerm: 0, votedFor: null };
+    loadState() {
+        return { ...this.state };
+    }
+    saveState(state) {
+        this.state = { ...state };
+    }
+    length() {
+        return this.entries.length;
+    }
+    getEntry(index) {
+        if (index < 1 || index > this.entries.length) {
+            return undefined;
+        }
+        return this.entries[index - 1];
+    }
+    getTerm(index) {
+        return this.getEntry(index)?.term ?? 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;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSW5NZW1vcnlSYWZ0TG9nLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3JhZnQvbG9nL0luTWVtb3J5UmFmdExvZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFJQTs7O0dBR0c7QUFDSCxNQUFNLE9BQU8sZUFBZTtJQUNsQixPQUFPLEdBQWtCLEVBQUUsQ0FBQztJQUM1QixLQUFLLEdBQXdCLEVBQUUsV0FBVyxFQUFFLENBQUMsRUFBRSxRQUFRLEVBQUUsSUFBSSxFQUFFLENBQUM7SUFFeEUsU0FBUztRQUNQLE9BQU8sRUFBRSxHQUFHLElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FBQztJQUMzQixDQUFDO0lBRUQsU0FBUyxDQUFDLEtBQTBCO1FBQ2xDLElBQUksQ0FBQyxLQUFLLEdBQUcsRUFBRSxHQUFHLEtBQUssRUFBRSxDQUFDO0lBQzVCLENBQUM7SUFFRCxNQUFNO1FBQ0osT0FBTyxJQUFJLENBQUMsT0FBTyxDQUFDLE1BQU0sQ0FBQztJQUM3QixDQUFDO0lBRUQsUUFBUSxDQUFDLEtBQWE7UUFDcEIsSUFBSSxLQUFLLEdBQUcsQ0FBQyxJQUFJLEtBQUssR0FBRyxJQUFJLENBQUMsT0FBTyxDQUFDLE1BQU0sRUFBRTtZQUM1QyxPQUFPLFNBQVMsQ0FBQztTQUNsQjtRQUNELE9BQU8sSUFBSSxDQUFDLE9BQU8sQ0FBQyxLQUFLLEdBQUcsQ0FBQyxDQUFDLENBQUM7SUFDakMsQ0FBQztJQUVELE9BQU8sQ0FBQyxLQUFhO1FBQ25CLE9BQU8sSUFBSSxDQUFDLFFBQVEsQ0FBQyxLQUFLLENBQUMsRUFBRSxJQUFJLElBQUksQ0FBQyxDQUFDO0lBQ3pDLENBQUM7SUFFRCxNQUFNLENBQUMsT0FBc0I7UUFDM0IsSUFBSSxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsR0FBRyxPQUFPLENBQUMsQ0FBQztJQUNoQyxDQUFDO0lBRUQsWUFBWSxDQUFDLEtBQWE7UUFDeEIsSUFBSSxLQUFLLEdBQUcsQ0FBQztZQUFFLE9BQU87UUFDdEIsSUFBSSxDQUFDLE9BQU8sQ0FBQyxNQUFNLEdBQUcsS0FBSyxHQUFHLENBQUMsQ0FBQztJQUNsQyxDQUFDO0lBRUQsVUFBVSxDQUFDLFVBQWtCLEVBQUUsUUFBZ0I7UUFDN0MsSUFBSSxVQUFVLEdBQUcsUUFBUSxJQUFJLFVBQVUsR0FBRyxJQUFJLENBQUMsT0FBTyxDQUFDLE1BQU07WUFBRSxPQUFPLEVBQUUsQ0FBQztRQUN6RSxPQUFPLElBQUksQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLFVBQVUsR0FBRyxDQUFDLEVBQUUsUUFBUSxDQUFDLENBQUM7SUFDdEQsQ0FBQztJQUVELFNBQVM7UUFDUCxPQUFPLElBQUksQ0FBQyxPQUFPLENBQUMsTUFBTSxDQUFDO0lBQzdCLENBQUM7SUFFRCxRQUFRO1FBQ04sSUFBSSxJQUFJLENBQUMsT0FBTyxDQUFDLE1BQU0sS0FBSyxDQUFDO1lBQUUsT0FBTyxDQUFDLENBQUM7UUFDeEMsT0FBTyxJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsTUFBTSxHQUFHLENBQUMsQ0FBQyxDQUFDLElBQUksQ0FBQztJQUNwRCxDQUFDO0NBQ0YifQ==

package/build/module/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/module/raft/log/LocalStorageRaftLog.js

@@ -0,0 +1,12 @@
+import { StorageRaftLog } from './StorageRaftLog';
+/**
+ * localStorage-backed Raft log implementation.
+ * Survives page refreshes — suitable for durable sessions where peers
+ * may rejoin after a restart.
+ */
+export class LocalStorageRaftLog extends StorageRaftLog {
+    constructor(namespace) {
+        super(localStorage, namespace);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTG9jYWxTdG9yYWdlUmFmdExvZy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9yYWZ0L2xvZy9Mb2NhbFN0b3JhZ2VSYWZ0TG9nLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUVsRDs7OztHQUlHO0FBQ0gsTUFBTSxPQUFPLG1CQUFpQyxTQUFRLGNBQWlCO0lBQ3JFLFlBQVksU0FBaUI7UUFDM0IsS0FBSyxDQUFDLFlBQVksRUFBRSxTQUFTLENBQUMsQ0FBQztJQUNqQyxDQUFDO0NBQ0YifQ==

package/build/module/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/module/raft/log/RaftLog.js

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

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

package/build/module/raft/log/RaftLog.test-util.js

@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2026 Wenhao Ji <predator.ray@gmail.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+export function runCommonRaftLogTests(t, createLog) {
+    const log = createLog();
+    // Initial state
+    t.is(log.length(), 0);
+    t.is(log.lastIndex(), 0);
+    t.is(log.lastTerm(), 0);
+    t.deepEqual(log.loadState(), { currentTerm: 0, votedFor: null });
+    // Append and retrieve
+    const entries = [
+        { term: 1, command: 'a' },
+        { term: 1, command: 'b' },
+        { term: 2, command: 'c' },
+    ];
+    log.append(entries);
+    t.is(log.length(), 3);
+    t.is(log.lastIndex(), 3);
+    t.is(log.lastTerm(), 2);
+    t.deepEqual(log.getEntry(1), entries[0]);
+    t.deepEqual(log.getEntry(2), entries[1]);
+    t.deepEqual(log.getEntry(3), entries[2]);
+    t.is(log.getEntry(0), undefined);
+    t.is(log.getEntry(4), undefined);
+    // getTerm
+    t.is(log.getTerm(1), 1);
+    t.is(log.getTerm(3), 2);
+    t.is(log.getTerm(0), 0);
+    t.is(log.getTerm(4), 0);
+    // getEntries
+    t.deepEqual(log.getEntries(1, 2), [entries[0], entries[1]]);
+    t.deepEqual(log.getEntries(2, 3), [entries[1], entries[2]]);
+    t.deepEqual(log.getEntries(1, 3), entries);
+    t.deepEqual(log.getEntries(2, 2), [entries[1]]);
+    t.deepEqual(log.getEntries(3, 2), []);
+    t.deepEqual(log.getEntries(4, 5), []);
+    // Persistent state
+    const newState = { currentTerm: 5, votedFor: 'node1' };
+    log.saveState(newState);
+    t.deepEqual(log.loadState(), newState);
+    // Truncate
+    log.truncateFrom(2);
+    t.is(log.length(), 1);
+    t.is(log.lastIndex(), 1);
+    t.is(log.lastTerm(), 1);
+    t.deepEqual(log.getEntry(1), entries[0]);
+    t.is(log.getEntry(2), undefined);
+    // Truncate from 1
+    log.truncateFrom(1);
+    t.is(log.length(), 0);
+    t.is(log.lastIndex(), 0);
+    t.is(log.lastTerm(), 0);
+    // Truncate with index <= 0 (should be safe, usually does nothing or clears all)
+    log.append(entries);
+    log.truncateFrom(0);
+    t.is(log.length(), 3, 'truncateFrom(0) should be a no-op per implementation');
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/raft/log/SessionStorageRaftLog.d.ts

@@ -0,0 +1,9 @@
+import { StorageRaftLog } from './StorageRaftLog';
+/**
+ * sessionStorage-backed Raft log implementation.
+ * Survives page refreshes within the same tab, but is cleared when the tab is closed.
+ * Useful for short-lived Raft groups or testing.
+ */
+export declare class SessionStorageRaftLog<T = unknown> extends StorageRaftLog<T> {
+    constructor(namespace: string);
+}

package/build/module/raft/log/SessionStorageRaftLog.js

@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2026 Wenhao Ji <predator.ray@gmail.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+import { StorageRaftLog } from './StorageRaftLog';
+/**
+ * sessionStorage-backed Raft log implementation.
+ * Survives page refreshes within the same tab, but is cleared when the tab is closed.
+ * Useful for short-lived Raft groups or testing.
+ */
+export class SessionStorageRaftLog extends StorageRaftLog {
+    constructor(namespace) {
+        super(sessionStorage, namespace);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiU2Vzc2lvblN0b3JhZ2VSYWZ0TG9nLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3JhZnQvbG9nL1Nlc3Npb25TdG9yYWdlUmFmdExvZy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0dBcUJHO0FBRUgsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRWxEOzs7O0dBSUc7QUFDSCxNQUFNLE9BQU8scUJBQW1DLFNBQVEsY0FBaUI7SUFDdkUsWUFBWSxTQUFpQjtRQUMzQixLQUFLLENBQUMsY0FBYyxFQUFFLFNBQVMsQ0FBQyxDQUFDO0lBQ25DLENBQUM7Q0FDRiJ9

package/build/module/raft/log/StorageRaftLog.d.ts

@@ -0,0 +1,28 @@
+import { LogEntry, RaftPersistentState } from '../types';
+import { RaftLog } from './RaftLog';
+/**
+ * Common base class for Storage-backed Raft log implementations (localStorage or sessionStorage).
+ *
+ * Storage layout (all keys prefixed with `{prefix}`):
+ *   `{prefix}:state`          → JSON of RaftPersistentState
+ *   `{prefix}:log:length`     → number of log entries
+ *   `{prefix}:log:{index}`    → JSON of LogEntry at 1-based index
+ */
+export declare abstract class StorageRaftLog<T = unknown> implements RaftLog<T> {
+    protected readonly storage: Storage;
+    protected readonly prefix: string;
+    constructor(storage: Storage, namespace: string);
+    loadState(): RaftPersistentState;
+    saveState(state: RaftPersistentState): void;
+    length(): number;
+    protected setLength(len: number): void;
+    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;
+    /** Remove all stored data for this namespace from storage */
+    clear(): void;
+}

package/build/module/raft/log/StorageRaftLog.js

@@ -0,0 +1,114 @@
+/*
+ * Copyright (c) 2026 Wenhao Ji <predator.ray@gmail.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+/**
+ * Common base class for Storage-backed Raft log implementations (localStorage or sessionStorage).
+ *
+ * Storage layout (all keys prefixed with `{prefix}`):
+ *   `{prefix}:state`          → JSON of RaftPersistentState
+ *   `{prefix}:log:length`     → number of log entries
+ *   `{prefix}:log:{index}`    → JSON of LogEntry at 1-based index
+ */
+export class StorageRaftLog {
+    storage;
+    prefix;
+    constructor(storage, namespace) {
+        this.storage = storage;
+        this.prefix = `dandelion-raft:${namespace}`;
+    }
+    // --- Persistent state ---
+    loadState() {
+        const raw = this.storage.getItem(`${this.prefix}:state`);
+        if (!raw)
+            return { currentTerm: 0, votedFor: null };
+        return JSON.parse(raw);
+    }
+    saveState(state) {
+        this.storage.setItem(`${this.prefix}:state`, JSON.stringify(state));
+    }
+    // --- Log operations ---
+    length() {
+        const raw = this.storage.getItem(`${this.prefix}:log:length`);
+        return raw ? parseInt(raw, 10) : 0;
+    }
+    setLength(len) {
+        this.storage.setItem(`${this.prefix}:log:length`, String(len));
+    }
+    getEntry(index) {
+        if (index < 1 || index > this.length())
+            return undefined;
+        const raw = this.storage.getItem(`${this.prefix}:log:${index}`);
+        return raw ? JSON.parse(raw) : undefined;
+    }
+    getTerm(index) {
+        return this.getEntry(index)?.term ?? 0;
+    }
+    append(entries) {
+        let len = this.length();
+        for (const entry of entries) {
+            len++;
+            this.storage.setItem(`${this.prefix}:log:${len}`, JSON.stringify(entry));
+        }
+        this.setLength(len);
+    }
+    truncateFrom(index) {
+        if (index < 1)
+            return;
+        const len = this.length();
+        for (let i = index; i <= len; i++) {
+            this.storage.removeItem(`${this.prefix}:log:${i}`);
+        }
+        this.setLength(index - 1);
+    }
+    getEntries(startIndex, endIndex) {
+        const len = this.length();
+        if (startIndex > endIndex || startIndex > len)
+            return [];
+        const result = [];
+        const end = Math.min(endIndex, len);
+        for (let i = startIndex; i <= end; i++) {
+            const entry = this.getEntry(i);
+            if (entry)
+                result.push(entry);
+        }
+        return result;
+    }
+    lastIndex() {
+        return this.length();
+    }
+    lastTerm() {
+        const len = this.length();
+        if (len === 0)
+            return 0;
+        return this.getTerm(len);
+    }
+    /** Remove all stored data for this namespace from storage */
+    clear() {
+        const len = this.length();
+        for (let i = 1; i <= len; i++) {
+            this.storage.removeItem(`${this.prefix}:log:${i}`);
+        }
+        this.storage.removeItem(`${this.prefix}:log:length`);
+        this.storage.removeItem(`${this.prefix}:state`);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/build/module/raft/log/StorageRaftLog.test-util.d.ts

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

package/build/module/raft/log/StorageRaftLog.test-util.js

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2026 Wenhao Ji <predator.ray@gmail.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ */
+import { runCommonRaftLogTests } from './RaftLog.test-util';
+export function runStorageRaftLogTests(t, createLog) {
+    // 1. common RaftLog interface
+    const logCommon = createLog('test-common');
+    logCommon.clear();
+    runCommonRaftLogTests(t, () => logCommon);
+    // 2. persistence across instances
+    const namespace = 'test-persistence';
+    const log1 = createLog(namespace);
+    log1.clear();
+    log1.append([{ term: 1, command: 'persist-me' }]);
+    log1.saveState({ currentTerm: 1, votedFor: 'peer1' });
+    // Create a new instance with same namespace
+    const log2 = createLog(namespace);
+    t.is(log2.length(), 1);
+    t.deepEqual(log2.getEntry(1), { term: 1, command: 'persist-me' });
+    t.deepEqual(log2.loadState(), { currentTerm: 1, votedFor: 'peer1' });
+    // 3. clear removes all data in namespace
+    const namespaceClear = 'test-clear';
+    const logClear = createLog(namespaceClear);
+    logClear.append([{ term: 1, command: 'a' }]);
+    logClear.saveState({ currentTerm: 1, votedFor: 'b' });
+    logClear.clear();
+    t.is(logClear.length(), 0);
+    t.deepEqual(logClear.loadState(), { currentTerm: 0, votedFor: null });
+    t.is(logClear.getEntry(1), undefined);
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,53 @@
+/** Raft server role */
+export type RaftRole = 'follower' | 'candidate' | 'leader';
+/** A single entry in the Raft log */
+export interface LogEntry<T = unknown> {
+    /** The term in which this entry was created */
+    term: number;
+    /** The command/data stored in this entry */
+    command: T;
+}
+export interface RequestVoteArgs {
+    type: 'RequestVote';
+    term: number;
+    candidateId: string;
+    lastLogIndex: number;
+    lastLogTerm: number;
+}
+export interface RequestVoteResult {
+    type: 'RequestVoteResult';
+    term: number;
+    voteGranted: boolean;
+}
+export interface AppendEntriesArgs<T = unknown> {
+    type: 'AppendEntries';
+    term: number;
+    leaderId: string;
+    prevLogIndex: number;
+    prevLogTerm: number;
+    entries: LogEntry<T>[];
+    leaderCommit: number;
+}
+export interface AppendEntriesResult {
+    type: 'AppendEntriesResult';
+    term: number;
+    success: boolean;
+    /** The peer ID of the responder (so the leader knows who replied) */
+    responderId: string;
+    /** The index of the last entry the follower accepted (for updating matchIndex) */
+    matchIndex: number;
+}
+export type RaftMessage<T = unknown> = RequestVoteArgs | RequestVoteResult | AppendEntriesArgs<T> | AppendEntriesResult;
+/** Persistent Raft state that must survive restarts */
+export interface RaftPersistentState {
+    currentTerm: number;
+    votedFor: string | null;
+}
+export interface RaftNodeEvents<T = unknown> {
+    /** Fired when a new leader is elected (may be self) */
+    leaderChanged: (leaderId: string | null) => void;
+    /** Fired when a log entry is committed and should be applied */
+    committed: (entry: LogEntry<T>, index: number) => void;
+    /** Fired when this node's role changes */
+    roleChanged: (role: RaftRole) => void;
+}

package/build/module/raft/types.js

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

package/build/module/transport/PeerJSTransport.d.ts

@@ -0,0 +1,46 @@
+import Peer from 'peerjs';
+import { Transport, TransportEventName, TransportEvents } from './Transport';
+/** Minimal subset of PeerJS DataConnection used by PeerJSTransport. */
+export interface DataConnectionLike {
+    readonly peer: string;
+    send(data: unknown): void | Promise<void>;
+    close(): void;
+    on(event: 'open', cb: () => void): void;
+    on(event: 'data', cb: (data: unknown) => void): void;
+    on(event: 'close', cb: () => void): void;
+    on(event: 'error', cb: (err: Error) => void): void;
+}
+/** Minimal subset of PeerJS Peer used by PeerJSTransport. */
+export interface PeerLike {
+    on(event: 'open', cb: (id: string) => void): void;
+    on(event: 'connection', cb: (conn: DataConnectionLike) => void): void;
+    on(event: 'error', cb: (err: Error) => void): void;
+    on(event: 'close', cb: () => void): void;
+    connect(peerId: string, options?: unknown): DataConnectionLike;
+    destroy(): void;
+}
+export interface PeerJSTransportOptions {
+    /** PeerJS Peer constructor options (host, port, path, etc.) */
+    peerOptions?: ConstructorParameters<typeof Peer>[1];
+    /** Optional fixed peer ID; if omitted PeerJS assigns one */
+    peerId?: string;
+}
+export declare class PeerJSTransport implements Transport {
+    private readonly peer;
+    private readonly connections;
+    private readonly pendingConnections;
+    private _localPeerId;
+    private readonly listeners;
+    constructor(peer: PeerLike);
+    constructor(options?: PeerJSTransportOptions);
+    get localPeerId(): string | undefined;
+    get connectedPeers(): ReadonlyArray<string>;
+    connect(remotePeerId: string): void;
+    send(remotePeerId: string, data: unknown): Promise<void>;
+    broadcast(data: unknown): Promise<void>;
+    on<E extends TransportEventName>(event: E, listener: TransportEvents[E]): void;
+    off<E extends TransportEventName>(event: E, listener: TransportEvents[E]): void;
+    close(): void;
+    private setupConnection;
+    private emit;
+}