querysub 0.402.0 → 0.404.0

package/src/server.ts

@@ -1,48 +1,55 @@
-import "./forceProduction";
-import "./inject";
-
-import { isNode, isNodeTrue } from "socket-function/src/misc";
-import { SocketFunction } from "socket-function/SocketFunction";
-import { getThreadKeyCert } from "./-a-auth/certs";
-import { logErrors } from "./errors";
-import { pathValueAuthority2 } from "./0-path-value-core/NodePathAuthorities";
-import { green } from "socket-function/src/formatting/logColors";
-import { formatTime } from "socket-function/src/formatting/format";
-
-// As nice as it is that Querysub doesn't get imported, because our import hierarchy is so strict...
-//  we DO want to register some static diagnostics from Querysub, so... import it explicitly.
-import "./4-querysub/Querysub";
-import { getOurAuthorities } from "./config2";
-
-import { Querysub } from "./4-querysub/Querysub";
-
-logErrors(main());
-
-async function main() {
-    if (!isNode()) return;
-
-    console.log(`Time before main ${green(formatTime(process.uptime() * 1000))}`);
-
-    Error.stackTraceLimit = 20;
-
-    // SocketFunction.logMessages = true;
-    // SocketFunction.silent = false;
-
-    // ClientWatcher.DEBUG_READS = true;
-    // ClientWatcher.DEBUG_WRITES = true;
-
-    SocketFunction.WIRE_WARN_TIME = 50;
-
-    //setMaxChangeAge(1000 * 15);
-
-    //ActionsHistory.LOG_ACTION_HISTORY = "server";
-
-    //debugCoreMode();
-    //enableDebugRejections();
-
-    for (let authority of getOurAuthorities()) {
-        pathValueAuthority2.becomePathAuthority(authority);
-    }
-
-    await Querysub.hostService("PathValueServer");
+import "./forceProduction";
+import "./inject";
+
+import { isNode, isNodeTrue } from "socket-function/src/misc";
+import { SocketFunction } from "socket-function/SocketFunction";
+import { getThreadKeyCert } from "./-a-auth/certs";
+import { logErrors } from "./errors";
+import { green } from "socket-function/src/formatting/logColors";
+import { formatTime } from "socket-function/src/formatting/format";
+
+// As nice as it is that Querysub doesn't get imported, because our import hierarchy is so strict...
+//  we DO want to register some static diagnostics from Querysub, so... import it explicitly.
+import "./4-querysub/Querysub";
+
+import { Querysub } from "./4-querysub/Querysub";
+import { getDomain, isPublic } from "./config";
+import { enableDebugRejections } from "./0-path-value-core/pathValueCore";
+import { AuthoritySpec, PathRouter } from "./0-path-value-core/PathRouter";
+import { authorityLookup } from "./0-path-value-core/AuthorityLookup";
+import { startupAuthority } from "./0-path-value-core/startupAuthority";
+import { getOurAuthoritySpec } from "./0-path-value-core/PathRouterServerAuthoritySpec";
+
+logErrors(main());
+
+async function main() {
+    if (!isNode()) return;
+
+    console.log(`Time before main ${green(formatTime(process.uptime() * 1000))}`);
+
+    Error.stackTraceLimit = 20;
+
+    // SocketFunction.logMessages = true;
+    // SocketFunction.silent = false;
+
+    // ClientWatcher.DEBUG_READS = true;
+    // ClientWatcher.DEBUG_WRITES = true;
+
+    SocketFunction.WIRE_WARN_TIME = 50;
+
+    //setMaxChangeAge(1000 * 15);
+
+    //ActionsHistory.LOG_ACTION_HISTORY = "server";
+
+    //debugCoreMode();
+    if (!isPublic()) {
+        enableDebugRejections();
+    }
+
+    await Querysub.hostService("PathValueServer");
+
+    let spec = await getOurAuthoritySpec(true);
+    if (spec) {
+        await startupAuthority(spec);
+    }
 }

package/src/user-implementation/loginEmail.tsx

@@ -79,7 +79,7 @@ export function generateLoginEmail(config: {
             </table>
             {line(<div style={{ color: "rgb(255, 255, 255)" }}>
                 {/* Mess up the email so it isn't turned into a link by gmail. */}
-                Greetings <b>{email.replaceAll(".", ".​")}</b>. You have requested access to <a href={redirectURL} style={{ color: "rgb(153, 204, 255)" }}>{new URL(redirectURL).hostname}</a>.
+                Hi <b>{email.replaceAll(".", ".​")}</b>. You have requested access to <a href={redirectURL} style={{ color: "rgb(153, 204, 255)" }}>{new URL(redirectURL).hostname}</a>.
             </div>)}
             {line(<div style={{ color: "rgb(255, 255, 255)" }}>
                 If you did not make this request, please disregard this email. Your account is safe and no action is required.

package/tempnotes.txt

@@ -0,0 +1,67 @@
+
+BUGS:
+    FIXED? The value audit code says that the servers are missing values, And it's trying to send the test values between the different path value servers, even though they should be sharded to never share values. 
+    FIXED? The CYOA server keeps locking up
+        █ PathValueSerializer()                 46.34% (  66.6s = 75.3K *  765us   +  550K * 16.3us )
+    - The values keep syncing to both servers.
+    FIXED? The CYOA and the function server keep failing the audits as well. We might need to look at the logs to see how this could happen. It'll probably be obvious once we look at the logs for those paths.
+        - Is it because we're unwatching it? That would make a lot of sense. 
+        - I guess we can just step in and see if its watched
+            pathWatcher.watchers.get(path)
+            remoteWatcher.remoteWatchPaths.get(path)
+
+
+
+4) deploy ON THE SITE, to deploy our prefixes
+    - Do it via the site, to commit, publish, etc.
+3) gc, to split it into multiple directories
+4) Verify the site still works
+
+5) Verify that the sharded startup only loads in the paths it needs and isn't wasteful
+    - With 100 granularity the waste should be quite low. Unless we get REALLY unlucky? Hmm...
+
+6) Record path waste per PathValueServer, and add an admin warn component that requests this, then shows a warning for PathValueServers that have a high waste load %
+
+
+3) Test sharding again
+4) Verify the test page works well, and shards
+    - We have the function sharding, so the values shouldn't be sent to both servers because the function calls themselves should be sharded. 
+
+
+5) Test full path hash syncing, using data that's NOT in a prefix, and making sure we can sync it with keys to get some of it (and all of it)
+    a) When connecting from a trusted node, everything should work fine, the flag should pass through correctly, as remote watchers should know what flag to pass. 
+    b) When syncing from the client side, only synchronizing all the keys will work. But that does still need to work, and that still requires talking to the correct nodes and passing them the correct flags. 
+
+
+3) add code so that client-side we can get a breakdown of How many paths we have per authority. The goal is to just have most the paths come from a single authority. For reading, it's actually more efficient to talk to a single server rather than many servers, as it's not the amount of data, it's really just the latency overhead of talking to the server. And for writing, same thing, it's a lot easier to just write to one server. And if every single user is reading from every single server, it's just not feasible. It no longer scales well. 
+
+4) Get the AI to go through and add function remapping code. Basically, the idea is that we take the most accessed lookup that we're accessing and we use the key for that as our hash. For simple functions, we could actually automate this, but I'll see how the AI can do. 
+
+5) Verify we are mostly accessing paths on one authority
+
+
+7) Test 4 servers, sharded and redundant as the same time
+8) Verify on the test page
+
+8) Shard FunctionRunner
+    - Now is as good a time as any to deal with any of the sharding issues. And it should work easily enough...
+        - Verify the secondary run backup code works too.
+
+
+2) Add disk verification service
+    - pick a random authority => read the same we would as startup => do an extra backblaze getKeys and getInfo to make sure our cache is accurate => load in the data into memory => verify all old paths with that authority?
+    - I wasn't planning on verifying all paths, but we should be able to. They have to be old enough, of course. But we kind of already have that logic, so the AI can probably write it. The one somewhat hard thing, of course, is doing the hashes, especially because new data could cause the hashes to change because of GCing in memory. But if that's the case, for now we can error. Eventually we will warn and then we will drill down further to find the specific paths that are wrong. And if they actually are wrong, then we can actually error.
+
+
+2) Allow remote servers to talk to our local server, via using the connection the local server makes
+    AH! Add a connectivity page that we can go to, and you can tell all the servers to ping all the other servers, and then it will give us a full list of all that are inaccessible. We should start with this page, deploy it, Then witness that the remote server can't talk to our local servers. They don't even need to be local path value servers, just our local CYOA server, etc. 
+    I think what we need to do is we need to group connections by the resolved identity instead of by the underlying node ID. Maybe this is already done? (But I don't remember doing it).
+
+
+
+3) Deploy EVERYTHING (all services) to remote servers
+    3.0) deploy the path value servers shard it like we were testing locally
+        - 4, for redundancy and sharding
+    5) Deploy disk verification service
+
+

package/test.ts

@@ -3,109 +3,302 @@ chdir("D:/repos/qs-cyoa/");
 
 import "./inject";
 
+import { list, sort } from "socket-function/src/misc";
+import { formatNumber } from "socket-function/src/formatting/format";
+import { PathValueArchives, archives, archivesLocks, archivesRecycleBin, pathValueArchives } from "./src/0-path-value-core/pathValueArchives";
+import { trimPathStrToDepth } from "./src/path";
 import { Querysub } from "./src/4-querysub/QuerysubController";
-import { getErrorLogs, getLoggers2Async } from "./src/diagnostics/logs/diskLogger";
-import { watchAllValues } from "./src/diagnostics/logs/errorNotifications2/logWatcher";
-import { SocketFunction } from "socket-function/SocketFunction";
-import fs from "fs";
-import { getControllerNodeId, getControllerNodeIdList } from "./src/-g-core-values/NodeCapabilities";
+import { clientWatcher } from "./src/1-path-client/pathValueClientWatcher";
 import { delay } from "socket-function/src/batching";
-import { list, timeInSecond } from "socket-function/src/misc";
-import { lazy } from "socket-function/src/caching";
-import { formatNumber } from "socket-function/src/formatting/format";
-import { LZ4 } from "socket-function/src/lz4/LZ4";
-
-const paths = [
-    "D:/repos/qs-cyoa/database-storage/disklogs/join-0-dply-1756166400000-1756252800000.log",
-    "D:/repos/qs-cyoa/database-storage/disklogs/cyoa-0-dply-1756252800000-1756339200000.log",
-    "D:/repos/qs-cyoa/database-storage/disklogs/server-0-dply-1756425600000-1756512000000.log",
-    "D:/repos/qs-cyoa/database-storage/disklogs/server-1-dply-1756425600000-1756512000000.log",
-    "D:/repos/qs-cyoa/database-storage/disklogs/server-0-dply-1756684800000-1756771200000.log",
-    "D:/repos/qs-cyoa/database-storage/disklogs/server-1-dply-1756684800000-1756771200000.log",
-    "D:/repos/qs-cyoa/database-storage/disklogs/bootstrapper-0-dply-1756425600000-1756512000000.log",
-    "D:/repos/qs-cyoa/database-storage/disklogs/server-1-dply-1756598400000-1756684800000.log",
-    "D:/repos/qs-cyoa/database-storage/disklogs/server-0-dply-1756598400000-1756684800000.log",
-    "D:/repos/qs-cyoa/database-storage/disklogs/server-1-dply-1756252800000-1756339200000.log",
-    "D:/repos/qs-cyoa/database-storage/disklogs/server-0-dply-1756252800000-1756339200000.log",
-    "D:/repos/qs-cyoa/database-storage/disklogs/server-1-dply-1756512000000-1756598400000.log",
-    "D:/repos/qs-cyoa/database-storage/disklogs/server-0-dply-1756512000000-1756598400000.log",
-    "D:/repos/qs-cyoa/database-storage/disklogs/bootstrapper-0-dply-1756339200000-1756425600000.log",
-    "D:/repos/qs-cyoa/database-storage/disklogs/server-1-dply-1756339200000-1756425600000.log",
-    "D:/repos/qs-cyoa/database-storage/disklogs/server-0-dply-1756339200000-1756425600000.log",
-    "D:/repos/qs-cyoa/database-storage/disklogs/bootstrapper-0-dply-1756684800000-1756771200000.log",
-    "D:/repos/qs-cyoa/database-storage/disklogs/function-0-dply-1756425600000-1756512000000.log",
-    "D:/repos/qs-cyoa/database-storage/disklogs/bootstrapper-0-dply-1756598400000-1756684800000.log",
-    "D:/repos/qs-cyoa/database-storage/disklogs/bootstrapper-0-dply-1756512000000-1756598400000.log",
-    "D:/repos/qs-cyoa/database-storage/disklogs/function-0-dply-1756684800000-1756771200000.log",
-    "D:/repos/qs-cyoa/database-storage/disklogs/function-0-dply-1756598400000-1756684800000.log",
-    "D:/repos/qs-cyoa/database-storage/disklogs/cyoa-0-dply-1756598400000-1756684800000.log",
-    "D:/repos/qs-cyoa/database-storage/disklogs/cyoa-1-dply-1756598400000-1756684800000.log",
-    "D:/repos/qs-cyoa/database-storage/disklogs/cyoa-0-dply-1756512000000-1756598400000.log",
-    "D:/repos/qs-cyoa/database-storage/disklogs/cyoa-1-dply-1756512000000-1756598400000.log",
-    "D:/repos/qs-cyoa/database-storage/disklogs/server-0-dply-1756166400000-1756252800000.log",
-    "D:/repos/qs-cyoa/database-storage/disklogs/server-1-dply-1756166400000-1756252800000.log",
-    "D:/repos/qs-cyoa/database-storage/disklogs/join-0-dply-1756252800000-1756339200000.log",
-    "D:/repos/qs-cyoa/database-storage/disklogs/function-0-dply-1756252800000-1756339200000.log",
-    "D:/repos/qs-cyoa/database-storage/disklogs/join-0-dply-1756425600000-1756512000000.log",
-    "D:/repos/qs-cyoa/database-storage/disklogs/server-0-dply-1756080000000-1756166400000.log",
-    "D:/repos/qs-cyoa/database-storage/disklogs/gc-0-dply-1756425600000-1756512000000.log",
-    "D:/repos/qs-cyoa/database-storage/disklogs/join-0-dply-1756339200000-1756425600000.log",
-    "D:/repos/qs-cyoa/database-storage/disklogs/gc-0-dply-1756252800000-1756339200000.log",
-    "D:/repos/qs-cyoa/database-storage/disklogs/server-1-dply-1756080000000-1756166400000.log",
-    "D:/repos/qs-cyoa/database-storage/disklogs/gc-0-dply-1756339200000-1756425600000.log",
-    "D:/repos/qs-cyoa/database-storage/disklogs/join-0-dply-1756598400000-1756684800000.log",
-    "D:/repos/qs-cyoa/database-storage/disklogs/join-0-dply-1756684800000-1756771200000.log",
-    "D:/repos/qs-cyoa/database-storage/disklogs/cyoa-1-dply-1756252800000-1756339200000.log",
-    "D:/repos/qs-cyoa/database-storage/disklogs/join-0-dply-1756512000000-1756598400000.log",
-    "D:/repos/qs-cyoa/database-storage/disklogs/join-0-dply-1756080000000-1756166400000.log",
-];
-
-const FACTOR = 1;
-
-
-let getData = lazy(async () => {
-    let buffers: Buffer[] = [];
+import { authorityStorage } from "./src/0-path-value-core/pathValueCore";
+import { authorityLookup } from "./src/0-path-value-core/AuthorityLookup";
+import { getSnapshot, loadSnapshot, saveSnapshot } from "./src/0-path-value-core/archiveLocks/archiveSnapshots";
+import { Transaction } from "./src/0-path-value-core/archiveLocks/ArchiveLocks2";
+import { getArchives } from "./src/-a-archives/archives";
+import { unique } from "./src/misc";
+import { getAllAuthoritySpec, getOurAuthoritySpec } from "./src/0-path-value-core/PathRouterServerAuthoritySpec";
+import { PathRouter } from "./src/0-path-value-core/PathRouter";
+import { pathValueSerializer } from "./src/-h-path-value-serialize/PathValueSerializer";
+
+async function main() {
+    let paths = await pathValueArchives.getValuePaths(getAllAuthoritySpec());
+    paths = paths.filter(x => x.startsWith("P!REMAINING/"));
     for (let path of paths) {
-        let data = await fs.promises.readFile(path, "utf8");
-        buffers.push(Buffer.from(data));
-    }
-    return list(FACTOR).map(i => buffers.map(b => Buffer.from(b))).flat();
-});
+        let data = await archives().get(path);
+        if (!data) {
+            console.log(`Missing data file: ${path}`);
+            continue;
+        }
+        let loadObj = await PathValueArchives.loadValuesFromBuffer({ path, data });
 
-class TestControllerBase {
-    async test() {
-        return (await getData()).slice();
+        for (let value of loadObj.values) {
+            if (!PathRouter.matchesAuthoritySpec(getAllAuthoritySpec(), value.path)) {
+                throw new Error(`Value ${value.path} does not match authority spec`);
+            }
+            console.log(pathValueSerializer.getPathValue(value));
+        }
     }
-}
+    return;
+
+    // let path = "P!REMAINING/data_37c5d323e0f9a083.1ed7a7340a015680.querysubtest.com:52026_1775097754671.579_3_1_337_1775097652829.5793_1775097652829.5793_genesis_.data";
+    // let value = await archives().get(path);
+    // console.log(value?.toString());
+    // return;
+
+    // const path = list(500).map(x => "a").join("");
+    // await archives().set(path, Buffer.from("Hello, world!"));
+    // let value = await archives().get(path);
+    // console.log(value?.toString());
+
+    // function getName(path: string): string {
+    //     return path.split("/").at(-1)!;
+    // }
+
+    let allValuesObj = await pathValueArchives.loadValues({
+        nodeId: "",
+        prefixes: [],
+        routeStart: 0,
+        routeEnd: 1,
+    });
+    let allValues = Object.values(allValuesObj.values).flat();
+    console.log(`Total values loaded: ${formatNumber(allValues.length)}`);
+
+    // const badDeleteTransaction = "transaction_   tSeqNum=887   tWriteTime=1774715868374.9143   thread=9dc0   cCount=14   dCount=3482   create=X,X,X,X,X,X,X,X,X,X,X,X,X,X   delete=2@0977,3@0977,4@0977,1@0a2a,2@0a2a,3@0a2a,4@0a2...   .transaction";
+
+
+    // // const snapshotFile = "fileCount=3482   valueCount=1142614   byteCount=1074547019   time=1774724950047.202   hash=9d9acc132ccfbf898ae0c287391e48a88e4e3b3ed3beda16f81a0936e710ab07";
+    // // const snapshotFile2 = "fileCount=51   valueCount=1040817   byteCount=1019830353   time=1772831139982.38   hash=7c6acb6b705a8c68892f787e9c9f958b527bde8b60fb914045863a4bedc269e7";
+    // const fixedSnapshotFile = "fileCount=3482   valueCount=1142614   byteCount=1074547019   time=1774760576390.8218   hash=6ef29678cb600f6920d1615c265ff5150ba97c847143fae2832e26d9e1adf1cf";
+    // let snapshotFileObj = await getSnapshot(fixedSnapshotFile);
+
+    // // let files: string[] = [];
+    // // for (let file of snapshotFileObj.files) {
+    // //     files.push("NEW_remaining/" + getName(file.file));
+    // // }
+    // // let joinedSnapshot = await saveSnapshot({ files });
+    // // console.log(`Joined snapshot: ${joinedSnapshot.file}`);
+    // //await loadSnapshot({ overview: { file: fixedSnapshotFile }, noExit: true, hackNoDelete: true });
+
+    // let snapshot = await getSnapshot(fixedSnapshotFile);
+    // let found = 0;
+    // let recycleBin = 0;
+    // for (let file of snapshot.files) {
+    //     let data = await archives().get(file.file);
+    //     if (data) {
+    //         found++;
+    //         console.log("Found");
+    //     } else if (await archivesRecycleBin().get(file.file)) {
+    //         recycleBin++;
+    //         console.log("Found in recycle bin");
+    //     } else {
+    //         console.log("MISSING!");
+    //     }
+    // }
+    // // console.log(`Found ${found}/${snapshot.files.length} files | Recycle bin: ${recycleBin}`);
 
-const TestController = SocketFunction.register("TestController-019ca5fa-52ef-73bf-b918-4d9cde51b618", new TestControllerBase(), () => ({
-    test: {
-        //compress: false
-    },
-}));
-function compareBuffers(result: Buffer[], correct: Buffer[]) {
-    if (result.length !== correct.length) throw new Error(`Result does not match correct: ${result.length} !== ${correct.length}`);
-    for (let i = 0; i < result.length; i++) {
-        if (!result[i].equals(correct[i])) throw new Error(`Result does not match correct: ${result[i].length} !== ${correct[i].length}, at index ${i}`);
+    //await loadSnapshot({ overview: { file: fixedSnapshotFile }, noExit: true, hackNoDelete: true });
+
+
+
+    // // let joinedFiles = unique([...snapshot1.files, ...snapshot2.files].map(x => x.file));
+    // // require("debugbreak")(2);
+    // // debugger;
+    // // let joinedSnapshot = await saveSnapshot({ files: joinedFiles });
+    // // console.log(`Joined snapshot: ${joinedSnapshot.file}`);
+    // // let joinedSnapshotFile = "fileCount=3482   valueCount=1142614   byteCount=1074547019   time=1774745293898.8706   hash=9d9acc132ccfbf898ae0c287391e48a88e4e3b3ed3beda16f81a0936e710ab07";
+    // // joinedSnapshotFile = snapshotFile2;
+
+    // // await loadSnapshot({ overview: { file: snapshotFile2 }, noExit: true, hackNoDelete: true });
+
+    /*
+    let allFiles = await getArchives("").find("");
+    let allFileNames = new Set(allFiles.map(getName));
+
+    let joinedSnapshot = await getSnapshot(snapshotFile2);
+
+    let countByExtension = new Map<string, { value: number }>();
+    let found = 0;
+    let recycleBin = 0;
+    for (let file of joinedSnapshot.files) {
+        let extension = file.file.split(".").pop() || "";
+        let existing = countByExtension.get(extension);
+        if (!existing) {
+            existing = { value: 0 };
+            countByExtension.set(extension, existing);
+        }
+        existing.value++;
+        let data = await archives().get(file.file);
+        if (data) {
+            found++;
+        } else if (await archivesRecycleBin().get(file.file)) {
+            recycleBin++;
+        } else if (allFileNames.has(getName(file.file))) {
+            require("debugbreak")(2);
+            debugger;
+        }
     }
-}
-async function main() {
-    await Querysub.hostService("testwatcher");
-    //SocketFunction.logMessages = true;
-
-    while (true) {
-        try {
-            let otherNode = await getControllerNodeId(TestController);
-            if (!otherNode) throw new Error("No other node found");
-            let result = (await TestController.nodes[otherNode].test());
-            let correct = (await getData());
-            compareBuffers(result, correct);
-            console.log(`Received ${formatNumber(result.reduce((a, b) => a + b.length, 0))} bytes from ${otherNode}`);
-        } catch (e: any) {
-            console.error(e);
+    console.log(Array.from(countByExtension.entries()).map(([extension, value]) => `${extension}: ${value.value}`).join(" | "));
+    console.log(`Found ${found}/${joinedSnapshot.files.length} files | Recycle bin: ${recycleBin}`);
+
+
+    //*/
+
+
+    // let joined = await saveSnapshot({ files: joinedFiles });
+    // console.log(`Joined snapshot: ${joined.file}`);
+
+    // let recycleBinFiles = await archivesRecycleBin().find("");
+
+    // //let snapshot = await getSnapshot(snapshotFile);
+    //await loadSnapshot({ overview: { file: joinedSnapshotFile }, noExit: true, hackNoDelete: true });
+    // require("debugbreak")(2);
+    // debugger;
+
+    //Ugh... we restored... SOME values. 34.4K. But we should have restored over 1 million. And... it doesn't work, of course.
+
+
+    //let recycleBinFiles = await archivesRecycleBin().find("");
+
+    /*
+    {
+        let snapshot = await getSnapshot(joinedSnapshotFile);
+        let snapshotNames = new Set(snapshot.files.map(x => getName(x.file)));
+
+        let archivesRoot = getArchives("");
+        let allFiles = await archivesRoot.find("");
+        let fullPaths = allFiles.filter(x => snapshotNames.has(getName(x)));
+        let correct = 0;
+        let wrong = 0;
+        let duplicate = 0;
+        let foundPaths = new Set<string>();
+        for (let i = 0; i < fullPaths.length; i++) {
+            let fullPath = fullPaths[i];
+            let name = getName(fullPath);
+            let correctPath = `path-values-recycle-bin/NEW_remaining/${name}`;
+            if (fullPath === correctPath) {
+                correct++;
+                continue;
+            }
+            wrong++;
+            if (foundPaths.has(name)) {
+                duplicate++;
+                continue;
+            }
+            console.log(`Path is wrong at ${i}/${fullPaths.length}: ${fullPath}`);
+            foundPaths.add(name);
+            await archivesRoot.move({
+                path: fullPath,
+                targetPath: correctPath,
+                target: archivesRoot,
+            });
         }
-        await delay(timeInSecond * 1);
+        console.log({ correct, wrong, duplicate, snapshotCount: snapshot.files.length, allCount: allFiles.length, fullPathsCount: fullPaths.length });
     }
+
+    //*/
+
+    // let recycleBinValues = await archivesRecycleBin().findInfo("");
+    // require("debugbreak")(2);
+    // debugger;
+
+    // // File =-.,querysubtest._com.,/data_0ee02faf16c0fadf.1ed7a7340a015680.querysubtest.com:58985_1773251893137_6_1_337_1773251743670_1773251743670_genesis_.data is not in the recycle bin, skipping
+
+    // // UGH... they values we delete are not in the recycle bin? Wtf...
+    // // Welp... files ARE KEPT after deletion natively, so maybe we can find them that way
+
+    // //todonext
+    // // "move" must be broken? Hmm...
+
+    // // HMM... Why do we have all these files in the root? That is surely not correct. These kinda look like our restored snapshot...
+    // // That would make sense if move lost its ability to nest values. Maybe due to our caching?
+
+
+
+    // //let snapshot = await getSnapshot(snapshotFile);
+
+
+
+    // let test = await archives().find("");
+    // console.log(test.length);
+
+
+
+    // We have 125K paths in the recycle bin. We read it surprisingly fast (2 minutes), but yeah... we need to fix this...
+    // So... archivesRecycleBin is VERY slow. Hmm... do we ever clean it up? I think we have to?
+    //  - We will want to thin the snapshots, not just remove all old ones.
+    // Hmm... So what even happened? 
+    //  - We have some transactions. It looks like they just deleted all the data. I guess our GC code accidentally matched everything.
+    // Ah, but... We know the files that were deleted, and they're just moved to the recycle bin. So we should just really go from the transactions to find all of the old values. 
+    // AND... somehow we deleted everything, all transactions, everything.
+    //  - Must have been during the attempt to restore it.
+    // let files = await archivesRecycleBin().findInfo("");
+    // console.log(files);
+    // console.log(files.length);
+    // require("debugbreak")(2);
+    // debugger;
+
+    // let snapshot = await pathValueArchives.loadValues({
+    //     type: "remaining",
+    //     excludedPrefixes: [],
+    // });
+    // let allValues = Object.values(snapshot.values).flat();
+    // console.log(`Total values loaded: ${formatNumber(allValues.length)}`);
+
+
+    // let transactionRaw = await archivesRecycleBin().get(badDeleteTransaction);
+    // if (!transactionRaw) throw new Error(`Transaction not found: ${badDeleteTransaction}`);
+    // console.log(transactionRaw?.toString());
+
+    // let transaction = JSON.parse(transactionRaw.toString()) as Transaction;
+    // let files = transaction.ops.filter(a => a.type === "delete").map(a => a.key);
+    // await saveSnapshot({ files });
+
+
+
+
+    // await Querysub.hostService("test");
+    // //let topology = await authorityLookup.getTopology();
+    // let parentPath = ".,querysubtest._com.,PathFunctionRunner.,book.,Data.,edittingBooks.,hkwnmoiwhuyqenbi.,books.,";
+    // clientWatcher.setWatches({
+    //     paths: new Set([]),
+    //     parentPaths: new Set([parentPath]),
+    //     callback: () => {
+    //         let value = authorityStorage.getPathsFromParent(parentPath);
+    //         console.log({ parentPaths: value?.size, isSynced: authorityStorage.isParentSynced(parentPath) });
+    //     }
+    // });
+
+    // await Querysub.hostService("test");
+
+    // let snapshot = await pathValueArchives.loadValues({
+    //     type: "remaining",
+    //     excludedPrefixes: [],
+    // });
+    // let allValues = Object.values(snapshot.values).flat();
+    // console.log(`Total values loaded: ${formatNumber(allValues.length)}`);
+
+    // let splitLevel = 4;
+    // let paths = new Map<string, {
+    //     count: number;
+    // }>();
+    // for (let value of allValues) {
+    //     let path = value.path;
+    //     let prefix = trimPathStrToDepth(path, splitLevel);
+    //     let entry = paths.get(prefix);
+    //     if (!entry) {
+    //         entry = { count: 0 };
+    //         paths.set(prefix, entry);
+    //     }
+    //     entry.count++;
+    // }
+    // // Log the 10 biggest paths
+    // let entries = Array.from(paths.entries());
+    // sort(entries, x => -x[1].count);
+    // for (let [path, entry] of entries.slice(0, 10)) {
+    //     console.log(`${formatNumber(entry.count)}\t${path}`);
+    // }
 }
 
-main().catch(console.error).finally(() => process.exit(0));
+main().catch(console.error)
+    .finally(() => process.exit(0))
+    ;