querysub 0.590.0 → 0.592.0

package/bin/stop-machine.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+
+require("typenode");
+require("../src/deployManager/stopMachineMain");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.590.0",
+  "version": "0.592.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
@@ -26,6 +26,8 @@
     "mc2": "yarn typenode ./src/diagnostics/debugger/mcp-server.ts --cwd D:/repos/qs-cyoa/",
     "autofix": "yarn typenode ./src/diagnostics/logs/errorTickets/autoFixerEntry.ts",
     "parameters-timeline": "yarn typenode ./src/deployManager/parametersTimelineMain.ts",
+    "setup-machine": "yarn typenode ./src/deployManager/setupMachineMain.ts",
+    "stop-machine": "yarn typenode ./src/deployManager/stopMachineMain.ts",
     "ssh-a-claude": "ssh root@a.querysubtest.com"
   },
   "bin": {
@@ -38,6 +40,7 @@
     "machine": "./bin/machine.js",
     "machine-alwaysup": "./bin/machine-alwaysup.js",
     "setup-machine": "./bin/setup-machine.js",
+    "stop-machine": "./bin/stop-machine.js",
     "gc": "./bin/gc.js",
     "gc-watch": "./bin/gc-watch.js",
     "gc-watch-public": "./bin/gc-watch-public.js",
@@ -71,7 +74,7 @@
     "node-forge": "https://github.com/sliftist/forge#e618181b469b07bdc70b968b0391beb8ef5fecd6",
     "pako": "^2.1.0",
     "peggy": "^5.0.6",
-    "sliftutils": "^1.7.65",
+    "sliftutils": "^1.7.69",
     "socket-function": "^1.2.27",
     "terser": "^5.31.0",
     "typenode": "^6.6.1",

package/src/-a-archives/archiveCache.ts

@@ -138,11 +138,17 @@ const getDiskMetricsBase = async () => {
     // We require our input to be a temp file, so our update can be atomic
     async function addCacheFile(archives: CacheKeySource, key: string, sourceTempFile: string): Promise<void> {
         let path = getArchiveCachePath(archives, key);
+        let sourceTempFileStat = await fs.promises.stat(sourceTempFile);
+        if (sourceTempFileStat.size === 0) {
+            try {
+                await fs.promises.unlink(sourceTempFile);
+            } catch { }
+            throw new Error(`Expected non-empty data when caching ${key}, was 0 bytes. Empty files are treated as deletes by the storage layer, so they must never be written or cached.`);
+        }
         let hasFile = fileSizes.some(x => x.path === path);
         if (hasFile) {
             removeFile(path);
         }
-        let sourceTempFileStat = await fs.promises.stat(sourceTempFile);
         availableBytes -= sourceTempFileStat.size;
         availableFiles--;
         sort(fileSizes, x => x.time);
@@ -196,14 +202,19 @@ const getDiskMetricsBase = async () => {
         let path = getArchiveCachePath(archives, key);
         let buffer: Buffer | undefined;
         let handle: fs.promises.FileHandle | undefined;
+        let isEmptyFile = false;
         try {
             handle = await fs.promises.open(path, "r");
             let stats = await handle.stat();
-            let start = config?.range?.start ?? 0;
-            let end = config?.range?.end ?? stats.size;
-            let readBuffer = Buffer.alloc(end - start);
-            let read = await handle.read(readBuffer, 0, end - start, start);
-            buffer = readBuffer.slice(0, read.bytesRead);
+            if (stats.size === 0) {
+                isEmptyFile = true;
+            } else {
+                let start = config?.range?.start ?? 0;
+                let end = config?.range?.end ?? stats.size;
+                let readBuffer = Buffer.alloc(end - start);
+                let read = await handle.read(readBuffer, 0, end - start, start);
+                buffer = readBuffer.slice(0, read.bytesRead);
+            }
         }
         catch { }
         finally {
@@ -211,6 +222,13 @@ const getDiskMetricsBase = async () => {
                 await handle.close();
             }
         }
+        if (isEmptyFile) {
+            removeFile(path);
+            try {
+                await fs.promises.unlink(path);
+            } catch { }
+            return undefined;
+        }
         if (buffer) {
             updateAccessTime(path);
             bumpAtimeIfStale(path);
@@ -355,7 +373,9 @@ export function wrapArchivesWithCache(archives: Archives, rootConfig?: {
             if (rootConfig?.immutable) {
                 try {
                     let stat = await fs.promises.stat(getArchiveCachePath(archives, fileName));
-                    return { writeTime: stat.mtimeMs, size: stat.size };
+                    if (stat.size > 0) {
+                        return { writeTime: stat.mtimeMs, size: stat.size };
+                    }
                 } catch {
                     // Not in our cache yet — fall through to the source.
                 }
@@ -363,6 +383,7 @@ export function wrapArchivesWithCache(archives: Archives, rootConfig?: {
             return archives.getInfo(fileName);
         },
         set: async (fileName: string, data: Buffer) => {
+            if (data.length === 0) throw new Error(`Expected non-empty data when setting ${fileName}, was 0 bytes. Empty writes are treated as deletes by the storage layer.`);
             let metrics = await getDiskMetrics();
             const tempPath = getTempFilePath();
             await fs.promises.writeFile(tempPath, data);

package/src/-a-archives/archiveCache2.ts

@@ -116,7 +116,7 @@ export function wrapArchivesWithCache2(archives: IArchives, rootConfig?: {
         get2: async (fileName: string, config?: GetConfig) => {
             let result = await archives.get2(fileName, config);
             // Range reads are partial, so they can't populate the cache.
-            if (result && !config?.range) {
+            if (result?.data && !config?.range) {
                 await cacheBuffer(fileName, result.data);
             }
             return result;
@@ -127,7 +127,9 @@ export function wrapArchivesWithCache2(archives: IArchives, rootConfig?: {
             if (rootConfig?.immutable) {
                 try {
                     let stat = await fs.promises.stat(getArchiveCachePath(archives, fileName));
-                    return { writeTime: stat.mtimeMs, size: stat.size };
+                    if (stat.size > 0) {
+                        return { writeTime: stat.mtimeMs, size: stat.size };
+                    }
                 } catch {
                     // Not in our cache yet — fall through to the source.
                 }
@@ -135,6 +137,7 @@ export function wrapArchivesWithCache2(archives: IArchives, rootConfig?: {
             return archives.getInfo(fileName);
         },
         set: async (fileName: string, data: Buffer, config?: SetConfig) => {
+            if (data.length === 0) throw new Error(`Expected non-empty data when setting ${fileName}, was 0 bytes. Empty writes are treated as deletes by the storage layer.`);
             let writtenKey = await archives.set(fileName, data, config);
             // VARIABLE_SHARD keys materialize into a different key on write, in which case
             //  fileName isn't the readable key, so caching under it would be wrong.

package/src/-a-archives/archives.ts

@@ -1,14 +1,4 @@
-import { isNode } from "socket-function/src/misc";
-import { getDomain, isNoNetwork } from "../config";
-import { getStorageDir, getSubFolder } from "../fs";
-import { getArchivesBackblaze, hasBackblazePermissions } from "./archivesBackBlaze";
-import { getArchivesLocal } from "./archivesDisk";
-import { magenta } from "socket-function/src/formatting/logColors";
-import debugbreak from "debugbreak";
-import { isClient } from "../config2";
-import { wrapArchivesWithCache } from "./archiveCache";
 import { Args } from "socket-function/src/types";
-import { IArchives } from "sliftutils/storage/IArchives";
 
 export interface Archives {
     getDebugName(): string;
@@ -105,8 +95,8 @@ export function createArchivesOverride<T extends Partial<Archives>>(
     };
 }
 
-export function nestArchives(path: string, archives: Archives): Archives & IArchives {
-    if (!path) return archives as any;
+export function nestArchives(path: string, archives: Archives): Archives {
+    if (!path) return archives;
     if (!path.endsWith("/")) {
         path = path + "/";
     }
@@ -116,7 +106,6 @@ export function nestArchives(path: string, archives: Archives): Archives & IArch
         }
         return file;
     }
-    // NOTE: Just ignore the errors in here. We're going to be getting rid of this soon enough. 
     return {
         getDebugName: () => archives.getDebugName() + "/" + path,
         get: (fileName: string, config) => archives.get(path + stripFilePrefix(fileName), config),
@@ -153,53 +142,3 @@ export function nestArchives(path: string, archives: Archives): Archives & IArch
     };
 }
 
-let archivesLogging = false;
-export function enableArchivesLogging() {
-    archivesLogging = true;
-}
-
-let cached = new Map<string, Archives>();
-export function getArchives(rootPath = ""): Archives {
-    let value = cached.get(rootPath);
-    if (!value) {
-        value = getArchivesBase(rootPath);
-        cached.set(rootPath, value);
-    }
-    return value;
-}
-export function getArchivesBase(rootPath = ""): Archives {
-    let archives: Archives;
-    let domain = getDomain();
-    if (isNoNetwork()) {
-        archives = getArchivesLocal(domain);
-        archives = nestArchives(rootPath, archives);
-    } else {
-        archives = getArchivesBackblaze(domain);
-        archives = nestArchives(rootPath, archives);
-        // Why did we think we should always cache? We absolutely should not. Even if we were checking
-        //  file hashes on every read (which we do not), it would still potentially fill the cache up
-        //  with large temporary files we have no intention of using (which might evict entries we
-        //  intend to use).
-        //archives = wrapArchivesWithCache(archives);
-    }
-    if (archivesLogging) {
-        archives.enableLogging();
-    }
-    return archives;
-}
-
-export function hasArchivesPermissions() {
-    if (isNoNetwork()) {
-        return true;
-    }
-    return hasBackblazePermissions();
-}
-
-if (isNode()) {
-    if (isNoNetwork()) {
-        console.log("Primary data storage: " + magenta(getStorageDir()));
-    } else {
-        console.log("Config storage path:  " + magenta(getStorageDir()));
-        console.log("Primary data storage: " + magenta(`backblaze:${getDomain()}`));
-    }
-}

package/src/-a-archives/archivesDisk.ts

@@ -1,12 +1,12 @@
 import { isNode } from "socket-function/src/misc";
 import os from "os";
-import { fsExistsAsync, getSubFolder } from "../fs";
+import { fsExistsAsync } from "../fs";
 import fs from "fs";
 import { blue, red, yellow } from "socket-function/src/formatting/logColors";
 import { measureFnc } from "socket-function/src/profiling/measure";
 import { delay } from "socket-function/src/batching";
 import debugbreak from "debugbreak";
-import { Archives, getArchives } from "./archives";
+import { Archives } from "./archives";
 import { cache, lazy } from "socket-function/src/caching";
 import { isDefined } from "../misc";
 
@@ -433,17 +433,6 @@ function unescapeFileName(fileName: string): string {
     return fileName;
 }
 
-export const getArchivesLocal = cache((domain: string): Archives => {
-
-    const archivesLocal = new ArchivesDisk();
-
-    if (isNode()) {
-        archivesLocal.LOCAL_ARCHIVE_FOLDER = getSubFolder(domain).replaceAll("\\", "/");
-    }
-
-    return archivesLocal;
-});
-
 export const getArchivesHome = cache((domain: string): Archives => {
     const archivesLocal = new ArchivesDisk();
 

package/src/-a-archives/archivesMemoryCache.ts

@@ -24,21 +24,29 @@ export function testDisableCache() {
     cacheDisabled = true;
 }
 
+export type MemoryCacheConfig = {
+    extraReadSize?: number;
+    maxSize?: number;
+    maxCount?: number;
+    // If the files are guaranteed to be immutable, then all reads, including reading entire file and reading any range, can be cached.
+    //  - Otherwise, we can't cache when the entire file is read, as there might be further appends after it.
+    //  - Also, it means if there's a range read that happens, if that range read doesn't return enough bytes, for example, we try to read from 0 to 100, but we only get 50 bytes back, we can only cache the 0 to 50, and then if they read from 0 to 100 again, we can use the cache, but we have to also read 50 to 100 from the source, because the file might have gotten larger.
+    fullyImmutable?: boolean;
+    stats?: ArchivesMemoryCacheStats;
+    sizeCache?: Map<string, number>;
+};
+
+/** The operations the cache actually needs from its source, so any archives flavor (old Archives or IArchives) can be cached. */
+export type MemoryCacheSource = {
+    get(path: string, config?: { range?: { start: number; end: number; } }): Promise<Buffer | undefined>;
+    getInfo(path: string): Promise<{ size: number } | undefined>;
+};
+
 /** Creates an in-memory cache for the archives. We expect that the values will only have values appended to them or be deleted. Also, if a value is deleted, we won't erase our in-memory cache, and so we will still allow reading from deleted values. */
-export function createArchivesMemoryCache(
-    archives: Archives,
-    config?: {
-        extraReadSize?: number;
-        maxSize?: number;
-        maxCount?: number;
-        // If the files are guaranteed to be immutable, then all reads, including reading entire file and reading any range, can be cached. 
-        //  - Otherwise, we can't cache when the entire file is read, as there might be further appends after it. 
-        //  - Also, it means if there's a range read that happens, if that range read doesn't return enough bytes, for example, we try to read from 0 to 100, but we only get 50 bytes back, we can only cache the 0 to 50, and then if they read from 0 to 100 again, we can use the cache, but we have to also read 50 to 100 from the source, because the file might have gotten larger. 
-        fullyImmutable?: boolean;
-        stats?: ArchivesMemoryCacheStats;
-        sizeCache?: Map<string, number>;
-    }
-): Archives {
+export function createMemoryCachedGet(
+    archives: MemoryCacheSource,
+    config?: MemoryCacheConfig
+) {
     let {
         maxSize = 1024 * 1024 * 1024 * 4,
         maxCount = 1000 * 1000,
@@ -221,8 +229,6 @@ export function createArchivesMemoryCache(
 
     async function cachedGet(path: string, getConfig?: {
         range?: { start: number; end: number; };
-        retryCount?: number;
-        fastRead?: boolean;
     }): Promise<Buffer | undefined> {
         if (cacheDisabled) {
             let result = await archives.get(path, getConfig);
@@ -374,7 +380,11 @@ export function createArchivesMemoryCache(
         return result;
     }
 
+    return cachedGet;
+}
+
+export function createArchivesMemoryCache(archives: Archives, config?: MemoryCacheConfig): Archives {
     return createArchivesOverride(archives, {
-        get: cachedGet
+        get: createMemoryCachedGet(archives, config),
     });
 }

package/src/-a-archives/archivesMemoryCache2.ts

@@ -0,0 +1,23 @@
+import { IArchives } from "sliftutils/storage/IArchives";
+import { createMemoryCachedGet, MemoryCacheConfig } from "./archivesMemoryCache";
+
+/** See createMemoryCachedGet — the same in-memory range cache, wrapping an IArchives (archives2). */
+export function createArchivesMemoryCache2(archives: IArchives, config?: MemoryCacheConfig): IArchives {
+    let cachedGet = createMemoryCachedGet(archives, config);
+    return {
+        get: cachedGet,
+        getDebugName: () => archives.getDebugName(),
+        hasWriteAccess: () => archives.hasWriteAccess(),
+        get2: (fileName, getConfig) => archives.get2(fileName, getConfig),
+        set: (fileName, data, setConfig) => archives.set(fileName, data, setConfig),
+        del: (fileName) => archives.del(fileName),
+        setLargeFile: (largeConfig) => archives.setLargeFile(largeConfig),
+        getInfo: (fileName) => archives.getInfo(fileName),
+        find: (prefix, findConfig) => archives.find(prefix, findConfig),
+        findInfo: (prefix, findConfig) => archives.findInfo(prefix, findConfig),
+        getURL: (path) => archives.getURL(path),
+        getConfig: () => archives.getConfig(),
+        getChangesAfter2: (changesConfig) => archives.getChangesAfter2(changesConfig),
+        getSyncStatus: archives.getSyncStatus && (() => archives.getSyncStatus!()),
+    };
+}

package/src/-d-trust/NetworkTrust2.ts

@@ -1,6 +1,6 @@
 import { measureWrap } from "socket-function/src/profiling/measure";
 import { getIdentityCA, getMachineId, getOwnMachineId } from "sliftutils/misc/https/certs";
-import { getArchives } from "../-a-archives/archives";
+import { getArchives2 } from "../-a-archives/archives2";
 import { isNode, throttleFunction, timeInHour, timeInSecond } from "socket-function/src/misc";
 import { SocketFunctionHook } from "socket-function/SocketFunctionTypes";
 import { SocketFunction } from "socket-function/SocketFunction";
@@ -21,7 +21,7 @@ import { magenta } from "socket-function/src/formatting/logColors";
 const UNTRUST_CACHE_TIME = 30 * timeInSecond;
 const TRUSTED_CACHE_RESET_INTERVAL = timeInHour;
 
-const archives = lazy(() => getArchives("trust2/"));
+const archives = lazy(() => getArchives2("trust2/"));
 
 export const requiresNetworkTrustHook: SocketFunctionHook = async config => {
     // HACK: On the clientside we strip the domain process and machine id, so we can no longer determine

package/src/-e-certs/certAuthority.ts

@@ -5,13 +5,13 @@ import { cache, lazy } from "socket-function/src/caching";
 import { hasDNSWritePermissions, setRecord } from "../-b-authorities/dnsAuthority";
 import { magenta } from "socket-function/src/formatting/logColors";
 import { createKeyStore } from "../persistentLocalStore";
-import { getArchives } from "../-a-archives/archives";
+import { getArchives2 } from "../-a-archives/archives2";
 import { isNoNetwork } from "../config";
 import { formatDateTime, formatTime } from "socket-function/src/formatting/format";
 import { delay } from "socket-function/src/batching";
 import { timeInMinute } from "socket-function/src/misc";
 
-const archives = lazy(() => getArchives(`https_certs_3/`));
+const archives = lazy(() => getArchives2(`https_certs_3/`));
 // Expire EXPIRATION_THRESHOLD% of the way through the certificate's lifetime
 const EXPIRATION_THRESHOLD = 0.4;
 // Let's Encrypt only accepts RSA or ECDSA account keys (not Ed25519, which is all sliftutils/certs generates).

package/src/-f-node-discovery/NodeDiscovery.ts

@@ -1,5 +1,5 @@
 import { SocketFunction } from "socket-function/SocketFunction";
-import { getArchives } from "../-a-archives/archives";
+import { getArchives2 } from "../-a-archives/archives2";
 import { getDomain, isDevDebugbreak, isNoNetwork, isPublic } from "../config";
 import { measureBlock } from "socket-function/src/profiling/measure";
 import { isNode, keyByArray, sha256Hash, throttleFunction, timeInMinute, timeInSecond } from "socket-function/src/misc";
@@ -56,7 +56,7 @@ let DEAD_NODE_POLL_COOLDOWN = timeInMinute * 5;
 
 let shutdown = false;
 
-const archives = lazy(() => getArchives("nodes/"));
+const archives = lazy(() => getArchives2("nodes/"));
 
 let logging = true;
 export function enableNodeDiscoveryLogging() {

package/src/0-path-value-core/AuthorityLookup.ts

@@ -1,8 +1,4 @@
 import { sort, timeInMinute, timeInSecond } from "socket-function/src/misc";
-import { nestArchives } from "../-a-archives/archives";
-import { getArchivesBackblaze } from "../-a-archives/archivesBackBlaze";
-import { archiveJSONT } from "../-a-archives/archivesJSONT";
-import { getDomain, isPublic } from "../config";
 import { cache, lazy } from "socket-function/src/caching";
 import { SocketFunction } from "socket-function/SocketFunction";
 import { delay, runInSerial, runInfinitePollCallAtStart } from "socket-function/src/batching";

package/src/0-path-value-core/ShardPrefixes.ts

@@ -10,10 +10,8 @@
 */
 
 import { isNode } from "typesafecss";
-import { nestArchives } from "../-a-archives/archives";
-import { getArchivesBackblaze } from "../-a-archives/archivesBackBlaze";
+import { getArchives2 } from "../-a-archives/archives2";
 import { archiveJSONT } from "../-a-archives/archivesJSONT";
-import { getDomain } from "../config";
 import { sort } from "socket-function/src/misc";
 import { getPathFromStr, getPathStr } from "../path";
 import { green, red } from "socket-function/src/formatting/logColors";
@@ -22,7 +20,7 @@ type PrefixObj = {
     prefixes: string[];
 };
 
-let prefixes = archiveJSONT<PrefixObj>(() => nestArchives("shard-prefixes/", getArchivesBackblaze(getDomain())));
+let prefixes = archiveJSONT<PrefixObj>(() => getArchives2("shard-prefixes/"));
 // We don't actually need a collection, we only need a single value. However, the collection interface is a lot more convenient than manually dealing with backplays files. 
 const key = "all";
 

package/src/0-path-value-core/archiveLocks/ArchiveLocks2.ts

@@ -32,6 +32,7 @@ const ARCHIVE_PROPAGATION_TIME = timeInSecond * 5;
 const MAX_APPLY_TRIES = 10;
 const CONCURRENT_READ_COUNT = 32;
 const CONCURRENT_WRITE_COUNT = 16;
+const CONCURRENT_TRANSACTION_READS = 8;
 
 /** Moves by copy-then-delete (IArchives has no move). copyArchiveFile stamps the target with the source's write time, so ordering-by-writeTime survives the move. A missing source means another process already moved it, which is fine. */
 async function moveArchiveFile(from: IArchives, to: IArchives, path: string): Promise<void> {
@@ -391,7 +392,7 @@ class TransactionLocker {
         let path = this.getConfirmKey(key);
         console.info(`Creating confirmation for ${key}, ${countLeft} left`);
         if (!await this.storage.getValue(path)) {
-            await this.storage.setValue(path, Buffer.from(""));
+            await this.storage.setValue(path, Buffer.from(JSON.stringify({ time: Date.now(), node: getOwnNodeId() })));
         }
         return path;
     }
@@ -410,7 +411,11 @@ class TransactionLocker {
                 if (!op) return;
                 if (op.type === "create") {
                     let key = op.key;
-                    await this.storage.setValue(key, op.value || Buffer.from(""));
+                    const value = op.value;
+                    if (!value || value.length === 0) {
+                        throw new Error(`Create op for ${key} has an empty value. Empty files are treated as deletes by the storage layer, so this create would vanish and the transaction could never be confirmed.`);
+                    }
+                    await this.storage.setValue(key, value);
                 }
             }
         };
@@ -494,11 +499,16 @@ class TransactionLocker {
                 createTime: number;
                 source: FileInfo;
             })[] = [];
-            for (let file of files) {
-                if (!file.file.endsWith(".transaction")) continue;
-                let tFile = file;
+            let transactionFiles = files.filter(x => x.file.endsWith(".transaction"));
+            // Set when any reader finds a missing value, so the other parallel readers stop early.
+            let missingValue = false;
+            const readTransaction = async (tFile: FileInfo) => {
+                if (missingValue) return;
                 let buffer = await this.storage.getValue(tFile.file);
-                if (!buffer) return false;
+                if (!buffer) {
+                    missingValue = true;
+                    return;
+                }
                 bufferCache.set(tFile.file, buffer);
                 let transaction: Transaction | undefined;
                 try {
@@ -507,7 +517,7 @@ class TransactionLocker {
                     // Maybe it is actively being written to? Or it is just broken. Skip it.
                     console.error(`Failed to parse transaction. Ignoring, ${tFile.file}, ${e.stack}`);
                 }
-                if (!transaction) continue;
+                if (!transaction) return;
 
                 let { name } = parsePath(tFile.file);
                 let kvp = parseFileNameKVP(name);
@@ -518,8 +528,11 @@ class TransactionLocker {
                     createTime: tFile.createTime,
                     source: tFile,
                 });
-            }
+            };
+            let readTransactionParallel = runInParallel({ parallelCount: CONCURRENT_TRANSACTION_READS }, readTransaction);
+            await Promise.all(transactionFiles.map(readTransactionParallel));
             this.perf.checkpoint("read transaction files");
+            if (missingValue) return false;
 
             // Check all of our files to see if any have changed (or if there a new files).
             //  Because we don't reuse file names, or change them, it means if a file exists
@@ -664,7 +677,7 @@ class TransactionLocker {
         }
         return true;
     }
-    private async applyTransaction(transaction: Transaction): Promise<void> {
+    private async applyTransaction(transaction: Transaction & { source: FileInfo }): Promise<void> {
         let createCount = transaction.ops.filter(a => a.type === "create").length;
         let deleteCount = transaction.ops.filter(a => a.type === "delete").length;
         let lockedFiles = transaction.lockedFilesMustEqual?.length;
@@ -685,7 +698,7 @@ class TransactionLocker {
                 if (op.type === "create") {
                     await this.createConfirm(op.key, opsRemaining.length);
                 } else if (op.type === "delete") {
-                    await this.deleteDataFile(op.key, `transaction (${getOwnNodeId()})`, opsRemaining.length);
+                    await this.deleteDataFile(op.key, `transaction for ${transaction.source.file}`, opsRemaining.length);
                 } else {
                     let unhandled: never = op;
                     throw new Error(`Unhandled type: ${unhandled}`);

package/src/0-path-value-core/archiveLocks/archiveSnapshots.ts

@@ -1,5 +1,4 @@
 import { sha256 } from "js-sha256";
-import { getArchives } from "../../-a-archives/archives";
 import { getAllNodeIds, getOwnThreadId } from "../../-f-node-discovery/NodeDiscovery";
 import { archives, pathValueArchives } from "../pathValueArchives";
 import { ignoreErrors, logErrors, timeoutToUndefinedSilent } from "../../errors";

package/src/0-path-value-core/pathValueArchives.ts

@@ -139,6 +139,7 @@ export class PathValueArchives {
         if (!config?.noFilter) {
             values = await this.filterForDiskStorage(values);
         }
+        if (values.length === 0) return undefined;
 
         let buffers = await pathValueSerializer.serialize(values, {
             noLocks: true,

package/src/4-deploy/edgeBootstrap.ts

@@ -18,26 +18,28 @@ declare global {
     var getEdgeNodeConfig: undefined | (() => Promise<EdgeNodeConfig>);
 }
 
-let getCachedConfig = cache(async (url: string): Promise<EdgeNodesIndex | undefined> => {
+let getCachedConfig = cache(async (urlsKey: string): Promise<EdgeNodesIndex | undefined> => {
     setTimeout(() => {
-        getCachedConfig.clear(url);
+        getCachedConfig.clear(urlsKey);
         // NOTE: We want deploying to be fast, so we don't cache for long. We also don't
         //  get the new value every 30 seconds, as we don't want to create too many requests.
     }, timeInSecond * 30);
 
-    try {
-        let response = await fetch(url);
-        return await response.json();
-    } catch {
-        return undefined;
+    for (let url of urlsKey.split("\n")) {
+        try {
+            let response = await fetch(url);
+            if (!response.ok) continue;
+            return await response.json();
+        } catch { }
     }
+    return undefined;
 });
 
 export async function getEdgeBootstrapScript(config: {
-    edgeNodeConfigURL: string;
+    edgeNodeConfigURLs: string[];
 }): Promise<string> {
     return await measureBlock(async function getEdgeBootstrapScript() {
-        let cachedConfig = await getCachedConfig(config.edgeNodeConfigURL);
+        let cachedConfig = await getCachedConfig(config.edgeNodeConfigURLs.join("\n"));
         let allowedArgs = ["--local"];
         // TODO: Be smarter about this (getting values and not just flags)
         let argv = process.argv.filter(x => allowedArgs.includes(x));
@@ -72,7 +74,7 @@ declare global {
 */
 
 async function edgeNodeFunction(config: {
-    edgeNodeConfigURL: string;
+    edgeNodeConfigURLs: string[];
     cachedConfig: EdgeNodesIndex | undefined;
     argv: string[];
 }) {
@@ -302,8 +304,45 @@ async function edgeNodeFunction(config: {
             return false;
         }
     }
+    // Fetches all the URLs at the same time and uses whichever responds first, aborting the rest (so slow sources don't hold sockets — chrome limits us to 6 per domain). Racing redundant sources is normally wasteful, but this is the very first request of the page load, so minimizing its latency is a huge win.
+    async function fetchFirstEdgeIndex(urls: string[]): Promise<EdgeNodesIndex> {
+        let controllers = urls.map(() => new AbortController());
+        return await new Promise<EdgeNodesIndex>((resolve, reject) => {
+            let resolved = false;
+            let pendingCount = urls.length;
+            let errors: string[] = [];
+            if (!pendingCount) {
+                reject(new Error(`No edge node config URLs to fetch`));
+                return;
+            }
+            urls.forEach((url, index) => {
+                void (async () => {
+                    try {
+                        let response = await fetch(url, { signal: controllers[index].signal });
+                        if (!response.ok) throw new Error(`Bad status ${response.status} from ${url}`);
+                        let edgeIndex = await response.json() as EdgeNodesIndex;
+                        if (resolved) return;
+                        resolved = true;
+                        for (let otherIndex = 0; otherIndex < controllers.length; otherIndex++) {
+                            if (otherIndex !== index) {
+                                controllers[otherIndex].abort();
+                            }
+                        }
+                        resolve(edgeIndex);
+                    } catch (e: any) {
+                        errors.push(`${url}: ${e?.stack ?? e}`);
+                        pendingCount--;
+                        if (!resolved && pendingCount === 0) {
+                            reject(new Error(`All edge node config URLs failed: ${errors.join(" | ")}`));
+                        }
+                    }
+                })();
+            });
+        });
+    }
+
     async function getEdgeNodeConfig(): Promise<EdgeNodeConfig> {
-        let edgeIndex = cachedConfig || await (await fetch(config.edgeNodeConfigURL)).json() as EdgeNodesIndex;
+        let edgeIndex = cachedConfig || await fetchFirstEdgeIndex(config.edgeNodeConfigURLs);
         cachedConfig = undefined;
 
         edgeIndex.edgeNodes.sort((a, b) => -(a.bootTime - b.bootTime));