cojson 0.7.23 → 0.7.26

package/dist/storage/index.js

@@ -1,4 +1,3 @@
-import { Effect, Either, Queue, Stream, SynchronizedRef, Deferred, } from "effect";
 import { connectedPeers } from "../streamUtils.js";
 import { chunkToKnownState, contentSinceChunk, mergeChunks, } from "./chunksAndKnownStates.js";
 import { readChunk, readHeader, textDecoder, writeBlock, writeToWal, } from "./FileSystem.js";
@@ -10,360 +9,336 @@ export class LSMStorage {
         this.toLocalNode = toLocalNode;
         this.headerCache = new Map();
         this.blockFileHandles = new Map();
-        this.coValues = SynchronizedRef.unsafeMake({});
-        this.currentWal = SynchronizedRef.unsafeMake(undefined);
-        void this.fromLocalNode.pipe(Stream.runForEach((msg) => Effect.gen(this, function* () {
-            if (msg.action === "done") {
-                return;
-            }
-            if (msg.action === "content") {
-                yield* this.handleNewContent(msg);
-            }
-            else {
-                yield* this.sendNewContent(msg.id, msg, undefined);
+        this.coValues = {};
+        this.currentWal = undefined;
+        let nMsg = 0;
+        const processMessages = async () => {
+            for await (const msg of fromLocalNode) {
+                console.log("Storage msg start", nMsg);
+                try {
+                    if (msg === "Disconnected" || msg === "PingTimeout") {
+                        throw new Error("Unexpected Disconnected message");
+                    }
+                    if (msg.action === "done") {
+                        return;
+                    }
+                    if (msg.action === "content") {
+                        await this.handleNewContent(msg);
+                    }
+                    else {
+                        await this.sendNewContent(msg.id, msg, undefined);
+                    }
+                }
+                catch (e) {
+                    console.error(new Error(`Error reading from localNode, handling msg\n\n${JSON.stringify(msg, (k, v) => k === "changes" || k === "encryptedChanges"
+                        ? v.slice(0, 20) + "..."
+                        : v)}`, { cause: e }));
+                }
+                console.log("Storage msg end", nMsg);
+                nMsg++;
             }
-        })), Effect.runPromise);
-        setTimeout(() => this.compact(), 20000);
-    }
-    sendNewContent(id, known, asDependencyOf) {
-        return SynchronizedRef.updateEffect(this.coValues, (coValues) => this.sendNewContentInner(coValues, id, known, asDependencyOf));
+        };
+        processMessages().catch((e) => console.error("Error in processMessages in storage", e));
+        setTimeout(() => this.compact().catch((e) => {
+            console.error("Error while compacting", e);
+        }), 20000);
     }
-    sendNewContentInner(coValues, id, known, asDependencyOf) {
-        return Effect.gen(this, function* () {
-            let coValue = coValues[id];
-            if (!coValue) {
-                coValue = yield* this.loadCoValue(id, this.fs);
-            }
-            if (!coValue) {
-                yield* Queue.offer(this.toLocalNode, {
-                    id: id,
-                    action: "known",
-                    header: false,
-                    sessions: {},
-                    asDependencyOf,
-                });
-                return coValues;
-            }
-            if (!known?.header &&
-                coValue.header?.ruleset.type === "ownedByGroup") {
-                coValues = yield* this.sendNewContentInner(coValues, coValue.header.ruleset.group, undefined, asDependencyOf || id);
-            }
-            else if (!known?.header &&
-                coValue.header?.ruleset.type === "group") {
-                const dependedOnAccounts = new Set();
-                for (const session of Object.values(coValue.sessionEntries)) {
-                    for (const entry of session) {
-                        for (const tx of entry.transactions) {
-                            if (tx.privacy === "trusting") {
-                                const parsedChanges = JSON.parse(tx.changes);
-                                for (const change of parsedChanges) {
-                                    if (change.op === "set" &&
-                                        change.key.startsWith("co_")) {
-                                        dependedOnAccounts.add(change.key);
-                                    }
+    async sendNewContent(id, known, asDependencyOf) {
+        let coValue = this.coValues[id];
+        if (!coValue) {
+            coValue = await this.loadCoValue(id, this.fs);
+        }
+        if (!coValue) {
+            this.toLocalNode
+                .push({
+                id: id,
+                action: "known",
+                header: false,
+                sessions: {},
+                asDependencyOf,
+            })
+                .catch((e) => console.error("Error while pushing known", e));
+            return;
+        }
+        if (!known?.header && coValue.header?.ruleset.type === "ownedByGroup") {
+            await this.sendNewContent(coValue.header.ruleset.group, undefined, asDependencyOf || id);
+        }
+        else if (!known?.header && coValue.header?.ruleset.type === "group") {
+            const dependedOnAccounts = new Set();
+            for (const session of Object.values(coValue.sessionEntries)) {
+                for (const entry of session) {
+                    for (const tx of entry.transactions) {
+                        if (tx.privacy === "trusting") {
+                            const parsedChanges = JSON.parse(tx.changes);
+                            for (const change of parsedChanges) {
+                                if (change.op === "set" &&
+                                    change.key.startsWith("co_")) {
+                                    dependedOnAccounts.add(change.key);
                                 }
                             }
                         }
                     }
                 }
-                for (const account of dependedOnAccounts) {
-                    coValues = yield* this.sendNewContentInner(coValues, account, undefined, asDependencyOf || id);
-                }
             }
-            const newContentMessages = contentSinceChunk(id, coValue, known).map((message) => ({ ...message, asDependencyOf }));
-            const ourKnown = chunkToKnownState(id, coValue);
-            yield* Queue.offer(this.toLocalNode, {
-                action: "known",
-                ...ourKnown,
-                asDependencyOf,
-            });
-            for (const message of newContentMessages) {
-                if (Object.keys(message.new).length === 0)
-                    continue;
-                yield* Queue.offer(this.toLocalNode, message);
+            for (const account of dependedOnAccounts) {
+                await this.sendNewContent(account, undefined, asDependencyOf || id);
             }
-            return { ...coValues, [id]: coValue };
-        });
+        }
+        const newContentMessages = contentSinceChunk(id, coValue, known).map((message) => ({ ...message, asDependencyOf }));
+        const ourKnown = chunkToKnownState(id, coValue);
+        this.toLocalNode
+            .push({
+            action: "known",
+            ...ourKnown,
+            asDependencyOf,
+        })
+            .catch((e) => console.error("Error while pushing known", e));
+        for (const message of newContentMessages) {
+            if (Object.keys(message.new).length === 0)
+                continue;
+            this.toLocalNode
+                .push(message)
+                .catch((e) => console.error("Error while pushing new content", e));
+        }
+        this.coValues[id] = coValue;
     }
-    withWAL(handler) {
-        return SynchronizedRef.updateEffect(this.currentWal, (wal) => Effect.gen(this, function* () {
-            let newWal = wal;
-            if (!newWal) {
-                newWal = yield* this.fs.createFile(`wal-${Date.now()}-${Math.random()
-                    .toString(36)
-                    .slice(2)}.jsonl`);
-            }
-            yield* handler(newWal);
-            return newWal;
-        }));
+    async withWAL(handler) {
+        if (!this.currentWal) {
+            this.currentWal = await this.fs.createFile(`wal-${Date.now()}-${Math.random()
+                .toString(36)
+                .slice(2)}.jsonl`);
+        }
+        await handler(this.currentWal);
     }
-    handleNewContent(newContent) {
-        return SynchronizedRef.updateEffect(this.coValues, (coValues) => Effect.gen(this, function* () {
-            const coValue = coValues[newContent.id];
-            const newContentAsChunk = {
-                header: newContent.header,
-                sessionEntries: Object.fromEntries(Object.entries(newContent.new).map(([sessionID, newInSession]) => [
-                    sessionID,
-                    [
-                        {
-                            after: newInSession.after,
-                            lastSignature: newInSession.lastSignature,
-                            transactions: newInSession.newTransactions,
-                        },
-                    ],
-                ])),
-            };
-            if (!coValue) {
-                if (newContent.header) {
-                    // console.log("Creating in WAL", newContent.id);
-                    yield* this.withWAL((wal) => writeToWal(wal, this.fs, newContent.id, newContentAsChunk));
-                    return {
-                        ...coValues,
-                        [newContent.id]: newContentAsChunk,
-                    };
-                }
-                else {
-                    // yield*
-                    //     Effect.promise(() =>
-                    //         this.toLocalNode.write({
-                    //             action: "known",
-                    //             id: newContent.id,
-                    //             header: false,
-                    //             sessions: {},
-                    //             isCorrection: true,
-                    //         })
-                    //     )
-                    // );
-                    yield* Effect.logWarning("Incontiguous incoming update for " + newContent.id);
-                    return coValues;
-                }
+    async handleNewContent(newContent) {
+        const coValue = this.coValues[newContent.id];
+        const newContentAsChunk = {
+            header: newContent.header,
+            sessionEntries: Object.fromEntries(Object.entries(newContent.new).map(([sessionID, newInSession]) => [
+                sessionID,
+                [
+                    {
+                        after: newInSession.after,
+                        lastSignature: newInSession.lastSignature,
+                        transactions: newInSession.newTransactions,
+                    },
+                ],
+            ])),
+        };
+        if (!coValue) {
+            if (newContent.header) {
+                // console.log("Creating in WAL", newContent.id);
+                await this.withWAL((wal) => writeToWal(wal, this.fs, newContent.id, newContentAsChunk));
+                this.coValues[newContent.id] = newContentAsChunk;
             }
             else {
-                const merged = mergeChunks(coValue, newContentAsChunk);
-                if (Either.isRight(merged)) {
-                    yield* Effect.logWarning("Non-contigous new content for " + newContent.id, Object.entries(coValue.sessionEntries).map(([session, entries]) => entries.map((entry) => ({
-                        session: session,
-                        after: entry.after,
-                        length: entry.transactions.length,
-                    }))), Object.entries(newContentAsChunk.sessionEntries).map(([session, entries]) => entries.map((entry) => ({
-                        session: session,
-                        after: entry.after,
-                        length: entry.transactions.length,
-                    }))));
-                    // yield* Effect.promise(() =>
-                    //     this.toLocalNode.write({
-                    //         action: "known",
-                    //         ...chunkToKnownState(newContent.id, coValue),
-                    //         isCorrection: true,
-                    //     })
-                    // );
-                    return coValues;
-                }
-                else {
-                    // console.log("Appending to WAL", newContent.id);
-                    yield* this.withWAL((wal) => writeToWal(wal, this.fs, newContent.id, newContentAsChunk));
-                    return { ...coValues, [newContent.id]: merged.left };
-                }
+                console.warn("Incontiguous incoming update for " + newContent.id);
+                return;
             }
-        }));
-    }
-    getBlockHandle(blockFile, fs) {
-        return Effect.gen(this, function* () {
-            let handleAndSize = this.blockFileHandles.get(blockFile);
-            if (!handleAndSize) {
-                handleAndSize = yield* Deferred.make();
-                this.blockFileHandles.set(blockFile, handleAndSize);
-                yield* Deferred.complete(handleAndSize, fs.openToRead(blockFile));
+        }
+        else {
+            const merged = mergeChunks(coValue, newContentAsChunk);
+            if (merged === "nonContigous") {
+                console.warn("Non-contigous new content for " + newContent.id, Object.entries(coValue.sessionEntries).map(([session, entries]) => entries.map((entry) => ({
+                    session: session,
+                    after: entry.after,
+                    length: entry.transactions.length,
+                }))), Object.entries(newContentAsChunk.sessionEntries).map(([session, entries]) => entries.map((entry) => ({
+                    session: session,
+                    after: entry.after,
+                    length: entry.transactions.length,
+                }))));
             }
-            return yield* Deferred.await(handleAndSize);
-        });
+            else {
+                // console.log("Appending to WAL", newContent.id);
+                await this.withWAL((wal) => writeToWal(wal, this.fs, newContent.id, newContentAsChunk));
+                this.coValues[newContent.id] = merged;
+            }
+        }
     }
-    loadCoValue(id, fs) {
-        return Effect.gen(this, function* () {
-            const files = this.fileCache || (yield* fs.listFiles());
-            this.fileCache = files;
-            const blockFiles = files.filter((name) => name.startsWith("L")).sort();
-            let result;
-            for (const blockFile of blockFiles) {
-                let cachedHeader = this.headerCache.get(blockFile);
-                let handleAndSize = this.blockFileHandles.get(blockFile);
-                if (!handleAndSize) {
-                    handleAndSize = yield* Deferred.make();
-                    this.blockFileHandles.set(blockFile, handleAndSize);
-                    yield* Deferred.complete(handleAndSize, fs.openToRead(blockFile));
-                }
-                const { handle, size } = yield* this.getBlockHandle(blockFile, fs);
-                // console.log("Attempting to load", id, blockFile);
-                if (!cachedHeader) {
-                    cachedHeader = {};
-                    const header = yield* readHeader(blockFile, handle, size, fs);
-                    for (const entry of header) {
-                        cachedHeader[entry.id] = {
-                            start: entry.start,
-                            length: entry.length,
-                        };
-                    }
-                    this.headerCache.set(blockFile, cachedHeader);
+    async getBlockHandle(blockFile, fs) {
+        if (!this.blockFileHandles.has(blockFile)) {
+            this.blockFileHandles.set(blockFile, fs.openToRead(blockFile));
+        }
+        return this.blockFileHandles.get(blockFile);
+    }
+    async loadCoValue(id, fs) {
+        const files = this.fileCache || (await fs.listFiles());
+        this.fileCache = files;
+        const blockFiles = files.filter((name) => name.startsWith("L")).sort();
+        let result;
+        for (const blockFile of blockFiles) {
+            let cachedHeader = this.headerCache.get(blockFile);
+            const { handle, size } = await this.getBlockHandle(blockFile, fs);
+            // console.log("Attempting to load", id, blockFile);
+            if (!cachedHeader) {
+                cachedHeader = {};
+                const header = await readHeader(blockFile, handle, size, fs);
+                for (const entry of header) {
+                    cachedHeader[entry.id] = {
+                        start: entry.start,
+                        length: entry.length,
+                    };
                 }
-                const headerEntry = cachedHeader[id];
-                // console.log("Header entry", id, headerEntry);
-                if (headerEntry) {
-                    const nextChunk = yield* readChunk(handle, headerEntry, fs);
-                    if (result) {
-                        const merged = mergeChunks(result, nextChunk);
-                        if (Either.isRight(merged)) {
-                            yield* Effect.logWarning("Non-contigous chunks while loading " + id, result, nextChunk);
-                        }
-                        else {
-                            result = merged.left;
-                        }
+                this.headerCache.set(blockFile, cachedHeader);
+            }
+            const headerEntry = cachedHeader[id];
+            // console.log("Header entry", id, headerEntry);
+            if (headerEntry) {
+                const nextChunk = await readChunk(handle, headerEntry, fs);
+                if (result) {
+                    const merged = mergeChunks(result, nextChunk);
+                    if (merged === "nonContigous") {
+                        console.warn("Non-contigous chunks while loading " + id, result, nextChunk);
                     }
                     else {
-                        result = nextChunk;
+                        result = merged;
                     }
                 }
-                // yield* fs.close(handle);
+                else {
+                    result = nextChunk;
+                }
             }
-            return result;
-        });
+            // await fs.close(handle);
+        }
+        return result;
     }
     async compact() {
-        await Effect.runPromise(Effect.gen(this, function* () {
-            const fileNames = yield* this.fs.listFiles();
-            const walFiles = fileNames.filter((name) => name.startsWith("wal-"));
-            walFiles.sort();
-            const coValues = new Map();
-            yield* Effect.log("Compacting WAL files", walFiles);
-            if (walFiles.length === 0)
-                return;
-            yield* SynchronizedRef.updateEffect(this.currentWal, (wal) => Effect.gen(this, function* () {
-                if (wal) {
-                    yield* this.fs.close(wal);
-                }
-                return undefined;
-            }));
-            for (const fileName of walFiles) {
-                const { handle, size } = yield* this.fs.openToRead(fileName);
-                if (size === 0) {
-                    yield* this.fs.close(handle);
+        const fileNames = await this.fs.listFiles();
+        const walFiles = fileNames.filter((name) => name.startsWith("wal-"));
+        walFiles.sort();
+        const coValues = new Map();
+        console.log("Compacting WAL files", walFiles);
+        if (walFiles.length === 0)
+            return;
+        const oldWal = this.currentWal;
+        this.currentWal = undefined;
+        if (oldWal) {
+            await this.fs.close(oldWal);
+        }
+        for (const fileName of walFiles) {
+            const { handle, size } = await this.fs.openToRead(fileName);
+            if (size === 0) {
+                await this.fs.close(handle);
+                continue;
+            }
+            const bytes = await this.fs.read(handle, 0, size);
+            const decoded = textDecoder.decode(bytes);
+            const lines = decoded.split("\n");
+            for (const line of lines) {
+                if (line.length === 0)
                     continue;
-                }
-                const bytes = yield* this.fs.read(handle, 0, size);
-                const decoded = textDecoder.decode(bytes);
-                const lines = decoded.split("\n");
-                for (const line of lines) {
-                    if (line.length === 0)
-                        continue;
-                    const chunk = JSON.parse(line);
-                    const existingChunk = coValues.get(chunk.id);
-                    if (existingChunk) {
-                        const merged = mergeChunks(existingChunk, chunk);
-                        if (Either.isRight(merged)) {
-                            yield* Effect.logWarning("Non-contigous chunks in " +
-                                chunk.id +
-                                ", " +
-                                fileName, existingChunk, chunk);
-                        }
-                        else {
-                            coValues.set(chunk.id, merged.left);
-                        }
+                const chunk = JSON.parse(line);
+                const existingChunk = coValues.get(chunk.id);
+                if (existingChunk) {
+                    const merged = mergeChunks(existingChunk, chunk);
+                    if (merged === "nonContigous") {
+                        console.log("Non-contigous chunks in " +
+                            chunk.id +
+                            ", " +
+                            fileName, existingChunk, chunk);
                     }
                     else {
-                        coValues.set(chunk.id, chunk);
+                        coValues.set(chunk.id, merged);
                     }
                 }
-                yield* this.fs.close(handle);
-            }
-            const highestBlockNumber = fileNames.reduce((acc, name) => {
-                if (name.startsWith("L" + MAX_N_LEVELS)) {
-                    const num = parseInt(name.split("-")[1]);
-                    if (num > acc) {
-                        return num;
-                    }
+                else {
+                    coValues.set(chunk.id, chunk);
                 }
-                return acc;
-            }, 0);
-            console.log([...coValues.keys()], fileNames, highestBlockNumber);
-            yield* writeBlock(coValues, MAX_N_LEVELS, highestBlockNumber + 1, this.fs);
-            for (const walFile of walFiles) {
-                yield* this.fs.removeFile(walFile);
             }
-            this.fileCache = undefined;
-            const fileNames2 = yield* this.fs.listFiles();
-            const blockFiles = fileNames2.filter((name) => name.startsWith("L")).sort();
-            const blockFilesByLevelInOrder = {};
-            for (const blockFile of blockFiles) {
-                const level = parseInt(blockFile.split("-")[0].slice(1));
-                if (!blockFilesByLevelInOrder[level]) {
-                    blockFilesByLevelInOrder[level] = [];
+            await this.fs.close(handle);
+        }
+        const highestBlockNumber = fileNames.reduce((acc, name) => {
+            if (name.startsWith("L" + MAX_N_LEVELS)) {
+                const num = parseInt(name.split("-")[1]);
+                if (num > acc) {
+                    return num;
                 }
-                blockFilesByLevelInOrder[level].push(blockFile);
             }
-            console.log(blockFilesByLevelInOrder);
-            for (let level = MAX_N_LEVELS; level > 0; level--) {
-                const nBlocksDesired = Math.pow(2, level);
-                const blocksInLevel = blockFilesByLevelInOrder[level];
-                if (blocksInLevel &&
-                    blocksInLevel.length > nBlocksDesired) {
-                    yield* Effect.log("Compacting blocks in level", level, blocksInLevel);
-                    const coValues = new Map();
-                    for (const blockFile of blocksInLevel) {
-                        const { handle, size, } = yield* this.getBlockHandle(blockFile, this.fs);
-                        if (size === 0) {
-                            continue;
-                        }
-                        const header = yield* readHeader(blockFile, handle, size, this.fs);
-                        for (const entry of header) {
-                            const chunk = yield* readChunk(handle, entry, this.fs);
-                            const existingChunk = coValues.get(entry.id);
-                            if (existingChunk) {
-                                const merged = mergeChunks(existingChunk, chunk);
-                                if (Either.isRight(merged)) {
-                                    yield* Effect.logWarning("Non-contigous chunks in " +
-                                        entry.id +
-                                        ", " +
-                                        blockFile, existingChunk, chunk);
-                                }
-                                else {
-                                    coValues.set(entry.id, merged.left);
-                                }
+            return acc;
+        }, 0);
+        console.log([...coValues.keys()], fileNames, highestBlockNumber);
+        await writeBlock(coValues, MAX_N_LEVELS, highestBlockNumber + 1, this.fs);
+        for (const walFile of walFiles) {
+            await this.fs.removeFile(walFile);
+        }
+        this.fileCache = undefined;
+        const fileNames2 = await this.fs.listFiles();
+        const blockFiles = fileNames2.filter((name) => name.startsWith("L")).sort();
+        const blockFilesByLevelInOrder = {};
+        for (const blockFile of blockFiles) {
+            const level = parseInt(blockFile.split("-")[0].slice(1));
+            if (!blockFilesByLevelInOrder[level]) {
+                blockFilesByLevelInOrder[level] = [];
+            }
+            blockFilesByLevelInOrder[level].push(blockFile);
+        }
+        console.log(blockFilesByLevelInOrder);
+        for (let level = MAX_N_LEVELS; level > 0; level--) {
+            const nBlocksDesired = Math.pow(2, level);
+            const blocksInLevel = blockFilesByLevelInOrder[level];
+            if (blocksInLevel && blocksInLevel.length > nBlocksDesired) {
+                console.log("Compacting blocks in level", level, blocksInLevel);
+                const coValues = new Map();
+                for (const blockFile of blocksInLevel) {
+                    const { handle, size } = await this.getBlockHandle(blockFile, this.fs);
+                    if (size === 0) {
+                        continue;
+                    }
+                    const header = await readHeader(blockFile, handle, size, this.fs);
+                    for (const entry of header) {
+                        const chunk = await readChunk(handle, entry, this.fs);
+                        const existingChunk = coValues.get(entry.id);
+                        if (existingChunk) {
+                            const merged = mergeChunks(existingChunk, chunk);
+                            if (merged === "nonContigous") {
+                                console.log("Non-contigous chunks in " +
+                                    entry.id +
+                                    ", " +
+                                    blockFile, existingChunk, chunk);
                             }
                             else {
-                                coValues.set(entry.id, chunk);
+                                coValues.set(entry.id, merged);
                             }
                         }
-                    }
-                    let levelBelow = blockFilesByLevelInOrder[level - 1];
-                    if (!levelBelow) {
-                        levelBelow = [];
-                        blockFilesByLevelInOrder[level - 1] = levelBelow;
-                    }
-                    const highestBlockNumberInLevelBelow = levelBelow.reduce((acc, name) => {
-                        const num = parseInt(name.split("-")[1]);
-                        if (num > acc) {
-                            return num;
+                        else {
+                            coValues.set(entry.id, chunk);
                         }
-                        return acc;
-                    }, 0);
-                    const newBlockName = yield* writeBlock(coValues, level - 1, highestBlockNumberInLevelBelow + 1, this.fs);
-                    levelBelow.push(newBlockName);
-                    // delete blocks that went into this one
-                    for (const blockFile of blocksInLevel) {
-                        const handle = yield* this.getBlockHandle(blockFile, this.fs);
-                        yield* this.fs.close(handle.handle);
-                        yield* this.fs.removeFile(blockFile);
                     }
                 }
+                let levelBelow = blockFilesByLevelInOrder[level - 1];
+                if (!levelBelow) {
+                    levelBelow = [];
+                    blockFilesByLevelInOrder[level - 1] = levelBelow;
+                }
+                const highestBlockNumberInLevelBelow = levelBelow.reduce((acc, name) => {
+                    const num = parseInt(name.split("-")[1]);
+                    if (num > acc) {
+                        return num;
+                    }
+                    return acc;
+                }, 0);
+                const newBlockName = await writeBlock(coValues, level - 1, highestBlockNumberInLevelBelow + 1, this.fs);
+                levelBelow.push(newBlockName);
+                // delete blocks that went into this one
+                for (const blockFile of blocksInLevel) {
+                    const handle = await this.getBlockHandle(blockFile, this.fs);
+                    await this.fs.close(handle.handle);
+                    await this.fs.removeFile(blockFile);
+                    this.blockFileHandles.delete(blockFile);
+                }
             }
-        }));
-        setTimeout(() => this.compact(), 5000);
+        }
+        setTimeout(() => this.compact().catch((e) => {
+            console.error("Error while compacting", e);
+        }), 5000);
     }
-    static async asPeer({ fs, trace, localNodeName = "local", }) {
-        const [localNodeAsPeer, storageAsPeer] = await Effect.runPromise(connectedPeers(localNodeName, "storage", {
+    static asPeer({ fs, trace, localNodeName = "local", }) {
+        const [localNodeAsPeer, storageAsPeer] = connectedPeers(localNodeName, "storage", {
             peer1role: "client",
             peer2role: "server",
             trace,
-        }));
+        });
         new LSMStorage(fs, localNodeAsPeer.incoming, localNodeAsPeer.outgoing);
         // return { ...storageAsPeer, priority: 200 };
         return storageAsPeer;