querysub 0.403.0 → 0.404.0

package/src/2-proxy/PathValueProxyWatcher.ts

@@ -15,11 +15,9 @@ import { ClientWatcher, WatchSpecData, clientWatcher } from "../1-path-client/pa
 import { createPathValueProxy, getPathFromProxy, getProxyPath, getProxyPathAndWatch, isValueProxy, isValueProxy2 } from "./pathValueProxy";
 import { authorityStorage, compareTime, ReadLock, epochTime, getNextTime, MAX_ACCEPTED_CHANGE_AGE, PathValue, Time, getCreatorId, getTimeUnique } from "../0-path-value-core/pathValueCore";
 import { runCodeWithDatabase, rawSchema } from "./pathDatabaseProxyBase";
-import { LOCAL_DOMAIN } from "../0-path-value-core/PathController";
 import debugbreak from "debugbreak";
 import { pathValueCommitter } from "../0-path-value-core/PathValueController";
 import { pathValueSerializer } from "../-h-path-value-serialize/PathValueSerializer";
-import { LOCAL_DOMAIN_PATH } from "../0-path-value-core/NodePathAuthorities";
 import { registerPeriodic } from "../diagnostics/periodic";
 import { remoteWatcher } from "../1-path-client/RemoteWatcher";
 import { Schema2, Schema2Fncs } from "./schema2";
@@ -29,7 +27,6 @@ import type { CallSpec } from "../3-path-functions/PathFunctionRunner";
 import type { FunctionMetadata } from "../3-path-functions/syncSchema";
 
 import { DEPTH_TO_DATA, MODULE_INDEX, getCurrentCall, getCurrentCallObj } from "../3-path-functions/PathFunctionRunner";
-import { inlineNestedCalls } from "../3-path-functions/syncSchema";
 import { interceptCallsBase, runCall } from "../3-path-functions/PathFunctionHelpers";
 import { deepCloneCborx } from "../misc/cloneHelpers";
 import { formatNumber, formatPercent, formatTime } from "socket-function/src/formatting/format";
@@ -118,6 +115,7 @@ export interface WatcherOptions<Result> {
     atomicWrites?: boolean;
 
     debugName?: string;
+    source?: string;
 
     watchFunction: () => Result;
     baseFunction?: Function;
@@ -281,7 +279,7 @@ const getAllowedLockDomainsPrefixes = function getTrustedDomains(): string[] {
         //  another user clicks at the same time and we race. Or... something? Maybe there
         //  are no cases when we need it... and it would definitely slow things down, so...
         //  maybe we just don't?
-        return [getPathStr1(LOCAL_DOMAIN)];
+        return [LOCAL_DOMAIN_PATH];
     }
 };
 
@@ -1500,7 +1498,7 @@ export class PathValueProxyWatcher {
 
             return result;
         }
-        function updateWatchers(initialTriggerWatch?: boolean) {
+        function updateWatchers() {
             watcher.lastWatches = {
                 paths: watcher.pendingWatches.paths,
                 parentPaths: watcher.pendingWatches.parentPaths,
@@ -1652,6 +1650,7 @@ export class PathValueProxyWatcher {
                     eventWrite: options.eventWrite,
                     dryRun: options.dryRun,
                     forcedUndefinedWrites,
+                    source: options.source,
                 });
             }
 
@@ -1882,7 +1881,7 @@ export class PathValueProxyWatcher {
             dispose();
         } else {
             // Set our watchers
-            updateWatchers(true);
+            updateWatchers();
             clientWatcher.explicitlyTriggerWatcher(trigger, {
                 synchronous: options.synchronousInit,
             });
@@ -2457,7 +2456,7 @@ const finishProxyAndTriggerNext = runInSerial(
         }
     }
 );
-function isProxyBlockedByOrder(proxy: SyncWatcher): boolean {
+export function isProxyBlockedByOrder(proxy: SyncWatcher): boolean {
     let order = getProxyOrder(proxy);
     if (order === undefined) return false;
     let index = binarySearchBasic(proxiesOrdered, x => getProxyOrder(x) || 0, order);
@@ -2505,4 +2504,7 @@ registerPeriodic(function logWatcherTypes() {
     }
 });
 
-// #endregion Proxy Ordering
+// #endregion Proxy Ordering
+
+import { inlineNestedCalls } from "../3-path-functions/syncSchema"; import { LOCAL_DOMAIN_PATH } from "../0-path-value-core/PathRouter";
+

package/src/2-proxy/archiveMoveHarness.ts

@@ -1,27 +1,21 @@
 import { formatNumber, formatTime } from "socket-function/src/formatting/format";
 import { blue, green, red } from "socket-function/src/formatting/logColors";
 import { measureBlock, measureWrap } from "socket-function/src/profiling/measure";
-import { AuthorityPath, pathValueAuthority2 } from "../0-path-value-core/NodePathAuthorities";
 import { FileInfo, ArchiveTransaction } from "../0-path-value-core/archiveLocks/ArchiveLocks";
 import { DecodedValuePath, pathValueArchives, PathValueArchives } from "../0-path-value-core/pathValueArchives";
 import { PathValue, VALUE_GC_THRESHOLD, FILE_VALUE_COUNT_LIMIT, FILE_SIZE_LIMIT, compareTime } from "../0-path-value-core/pathValueCore";
 import { getSingleSizeEstimate } from "../5-diagnostics/shared";
-import { getOurAuthorities } from "../config2";
 import { logNodeStats } from "../-0-hooks/hooks";
 import debugbreak from "debugbreak";
-
-// NOTE: We probably COULD load values with skipStrings+skipValues, for some GCers, as some
-//      GCing is as simple as, "if this value is undefined, delete it". But... we GC
-//      so seldomly, that it wouldn't make a difference (going from 1 minute of GC time
-//      per day to 20 seconds doesn't really matter).
-
-let lastFileWrites = new Map<string, string[]>();
+import { AuthorityEntry } from "../0-path-value-core/AuthorityLookup";
+import { AuthoritySpec, PathRouter } from "../0-path-value-core/PathRouter";
+import { getOurAuthoritySpec } from "../0-path-value-core/PathRouterServerAuthoritySpec";
 
 export async function runArchiveMover(config: {
     debugName: string;
     // Defaults to getOurAuthorities
     //  NOTE: Runs once per authority, as we want to keep data as sharded as possible
-    authorities?: AuthorityPath[];
+    authority?: AuthoritySpec;
 
     // If set we will provide all values. This means this is a high chance out of order values will
     //      be provided. Otherwise a consistent view of data at Date.now() - ARCHIVE_FLUSH_LIMIT
@@ -60,9 +54,8 @@ export async function runArchiveMover(config: {
              *      - Of course, if readLiveData is set this is Number.POSITIVE_INFINITY, as we
              *          try to provide the latest data... making this no longer an atomic snapshot.
              */
-            authority: AuthorityPath;
+            authority: AuthoritySpec;
             snapshotTime: number;
-            logKey: string;
         }
     ) => Promise<{
         newValues: "abort" | {
@@ -73,7 +66,7 @@ export async function runArchiveMover(config: {
         };
     }>;
 }) {
-    let authorities = config.authorities ?? getOurAuthorities();
+    let authority = config.authority ?? await getOurAuthoritySpec(true);
     let minAge = config.readLiveData ? Number.NEGATIVE_INFINITY : VALUE_GC_THRESHOLD;
     let minThreshold = Date.now() - minAge;
     // NOTE: If the value count is too high, parsing in the ArchiveViewer might crash the browser.
@@ -100,232 +93,207 @@ export async function runArchiveMover(config: {
         return meets;
     }
 
-    // NOTE: We COULD read from all authorities, handling them all at once. This MIGHT making
-    //      gcing more efficient. But... it also might not. We'll see.
-    //      - And, sharding shouldn't be random, it should be path based, just like GCing. Although,
-    //          if we have references, the best we can do is add parallel authorities to nodes,
-    //          so... we might have to handle all authorities at once, instead of looping like this...
-    for (let authority of authorities) {
-        let locker = await pathValueArchives.getArchiveLocker();
-        let matchedDirs = await pathValueArchives.getAuthorityDirs(authority);
-        let authorityDir = pathValueAuthority2.getArchiveDirectory(authority);
-
-        let startTime = Date.now();
-        let readCache = new Map<string, Buffer>();
-        let lastAborted = false;
-        let lastResult: "accepted" | "rejected" | "aborted" = "accepted";
+    let locker = await pathValueArchives.getArchiveLocker();
 
-        let inputBytes = 0;
-        let outputBytes = 0;
-        let inputValueCount = 0;
-        let outputValueCount = 0;
-        let inputFiles = 0;
-        let outputFiles = 0;
-        let abortedDueToInsufficientReduction = false;
+    let startTime = Date.now();
+    let readCache = new Map<string, Buffer>();
+    let lastAborted = false;
+    let lastResult: "accepted" | "rejected" | "aborted" = "accepted";
 
-        let reread = true;
-        while (reread) {
-            reread = false;
-            lastAborted = false;
-            lastResult = await locker.atomicSwapFiles({
-                allowDuplicates: config.allowDuplicates,
-            }, async (valueFiles, readFiles) => {
-                valueFiles = valueFiles.filter(x => matchedDirs.some(y => x.file.startsWith(y)));
+    let inputBytes = 0;
+    let outputBytes = 0;
+    let inputValueCount = 0;
+    let outputValueCount = 0;
+    let inputFiles = 0;
+    let outputFiles = 0;
+    let abortedDueToInsufficientReduction = false;
 
-                valueFiles = valueFiles.filter(x => {
-                    let obj = pathValueArchives.decodeDataPath(x.file);
-                    if (!obj.minTime) return true;
-                    return !(obj.minTime > minThreshold);
-                });
+    let reread = true;
+    while (reread) {
+        reread = false;
+        lastAborted = false;
+        lastResult = await locker.atomicSwapFiles({
+            allowDuplicates: config.allowDuplicates,
+        }, async (valueFiles, readFiles) => {
+            valueFiles = valueFiles.filter(x => PathRouter.overlapsPathIdentifier(authority, x.file));
 
-                let lastWriteHash = JSON.stringify(matchedDirs);
-                // NOTE: ACTUALLY, this doesn't work, as the oldFiles might values which have GC timers,
-                //      or which... are large, and just became deleted.
-                // let lastFiles = new Set(lastFileWrites.get(lastWriteHash) || []);
-                // let newFiles = valueFiles.filter(x => !lastFiles.has(x.file));
-                // // BEST case, ALL oldFiles are collapsed. And if that doesn't even cause a move,
-                // //  then just skip the check now
-                // if (!config.force && meetsThreshold({
-                //     inputFiles: valueFiles.length,
-                //     inputBytes: valueFiles.map(x => x.size).reduce((a, b) => a + b, 0),
-                //     outputFiles: newFiles.length,
-                //     outputBytes: newFiles.map(x => x.size).reduce((a, b) => a + b, 0),
-                // })) {
-                //     return [];
-                // }
+            valueFiles = valueFiles.filter(x => {
+                let obj = pathValueArchives.decodeDataPath(x.file);
+                if (!obj.minTime) return true;
+                return !(obj.minTime > minThreshold);
+            });
 
-                // Read files, and if any are missing, rerun until we can read all files
-                await measureBlock(async function locker_readFiles() {
-                    let remainingFiles = valueFiles.filter(x => !readCache.has(x.file));
-                    let buffers = await readFiles(remainingFiles);
-                    for (let i = 0; i < remainingFiles.length; i++) {
-                        let buffer = buffers[i];
-                        if (!buffer) {
-                            console.log(`File missing, re-reading`, remainingFiles[i].file);
-                            reread = true;
-                            break;
-                        }
-                        readCache.set(remainingFiles[i].file, buffer);
+            // Read files, and if any are missing, rerun until we can read all files
+            await measureBlock(async function locker_readFiles() {
+                let remainingFiles = valueFiles.filter(x => !readCache.has(x.file));
+                let buffers = await readFiles(remainingFiles);
+                for (let i = 0; i < remainingFiles.length; i++) {
+                    let buffer = buffers[i];
+                    if (!buffer) {
+                        console.log(`File missing, re-reading`, remainingFiles[i].file);
+                        reread = true;
+                        break;
                     }
-                });
-                if (reread) {
-                    console.log(`Files changed, re-reading`);
-                    return [];
-                }
-                function isValueIncluded(value: PathValue) {
-                    if (value.time.time > minThreshold) return false;
-                    if (!pathValueAuthority2.isInAuthority(authority, value.path)) return false;
-                    return true;
+                    readCache.set(remainingFiles[i].file, buffer);
                 }
+            });
+            if (reread) {
+                console.log(`Files changed, re-reading`);
+                return [];
+            }
+            function isValueIncluded(value: PathValue) {
+                if (value.time.time > minThreshold) return false;
+                if (!PathRouter.matchesAuthoritySpec(authority, value.path)) return false;
+                return true;
+            }
 
-                let mutatedFiles: FileInfo[] = [];
-                // authorityFolder => values
-                let floatingValues = new Map<string, PathValue[][]>();
-                let inputValues: PathValue[][] = [];
-                inputBytes = 0;
-                inputFiles = 0;
-                inputValueCount = 0;
+            let mutatedFiles: FileInfo[] = [];
+            // authorityFolder => values
+            let floatingValues = new Map<string, PathValue[][]>();
+            let inputValues: PathValue[][] = [];
+            inputBytes = 0;
+            inputFiles = 0;
+            inputValueCount = 0;
 
-                await measureBlock(async function locker_parseFiles() {
-                    for (let file of valueFiles) {
-                        let buffer = readCache.get(file.file);
-                        if (!buffer) {
-                            throw new Error(`Buffer missing for ${file.file}`);
-                        }
-                        inputBytes += buffer.byteLength;
-                        inputFiles++;
-                        let valuesObj = await PathValueArchives.loadValuesFromBuffer({
-                            path: file.file,
-                            data: buffer,
-                        });
-                        let values = valuesObj.values;
-                        inputValueCount += values.length;
-                        let includedValues: PathValue[] = [];
-                        let excludedValues: PathValue[] = [];
-                        for (let value of values) {
-                            if (isValueIncluded(value)) {
-                                includedValues.push(value);
-                            } else {
-                                excludedValues.push(value);
-                            }
-                        }
-                        if (includedValues.length === 0) {
-                            continue;
+            await measureBlock(async function locker_parseFiles() {
+                for (let file of valueFiles) {
+                    let buffer = readCache.get(file.file);
+                    if (!buffer) {
+                        throw new Error(`Buffer missing for ${file.file}`);
+                    }
+                    inputBytes += buffer.byteLength;
+                    inputFiles++;
+                    let valuesObj = await PathValueArchives.loadValuesFromBuffer({
+                        path: file.file,
+                        data: buffer,
+                    });
+                    let values = valuesObj.values;
+                    inputValueCount += values.length;
+                    let includedValues: PathValue[] = [];
+                    let excludedValues: PathValue[] = [];
+                    for (let value of values) {
+                        if (isValueIncluded(value)) {
+                            includedValues.push(value);
+                        } else {
+                            excludedValues.push(value);
                         }
-                        if (excludedValues.length > 0) {
-                            let fileDir = file.file.split("/").slice(0, -1).join("/") + "/";
-                            let list = floatingValues.get(fileDir);
-                            if (!list) {
-                                floatingValues.set(fileDir, list = []);
-                            }
-                            list.push(excludedValues);
+                    }
+                    if (includedValues.length === 0) {
+                        continue;
+                    }
+                    if (excludedValues.length > 0) {
+                        let fileDir = file.file.split("/").slice(0, -1).join("/") + "/";
+                        let list = floatingValues.get(fileDir);
+                        if (!list) {
+                            floatingValues.set(fileDir, list = []);
                         }
-                        inputValues.push(includedValues);
-                        mutatedFiles.push(file);
+                        list.push(excludedValues);
                     }
-                });
-
-                let inputValuesFlat = inputValues.flat();
-                let result = await measureBlock(async function locker_runApp() {
-                    return config.runMover({
-                        values: inputValuesFlat,
-                        authority,
-                        snapshotTime: minThreshold,
-                        logKey: authorityDir,
-                    });
-                }, `locker_app_${config.runMover.name}`);
-                if (result.newValues === "abort") {
-                    lastAborted = true;
-                    return [];
+                    inputValues.push(includedValues);
+                    mutatedFiles.push(file);
                 }
+            });
 
-                let transaction: ArchiveTransaction = {
-                    createFiles: [],
-                    deleteFiles: mutatedFiles,
-                };
-                const addValues = measureWrap(async function locker_addValues(dir: string, values: PathValue[], key: string) {
-                    let split = splitValuesBelowLimit({
-                        values,
-                        maxFileValueCount,
-                        maxFileByteCount,
-                    });
-                    outputFiles += split.length;
-                    outputValueCount += values.length;
-                    for (let splitValue of split) {
-                        let dataObj = await pathValueArchives.encodeValuePaths(splitValue.values, {
-                            pathOverrides: {
-                                sourceType: config.outputType,
-                                misc: key,
-                            },
-                        });
-                        if (!dataObj) continue;
-                        outputBytes += dataObj.data.byteLength;
-                        let fileName = pathValueArchives.encodeDataPath({
-                            ...pathValueArchives.getDefaultValuePathInput(),
-                            valueCount: splitValue.values.length,
-                            byteCount: dataObj.data.byteLength,
-                            minTime: splitValue.minTime,
-                            maxTime: splitValue.maxTime,
-                            sourceType: config.outputType,
-                            misc: key,
-                        });
-                        transaction.createFiles.push({
-                            data: dataObj.data,
-                            file: dir + fileName,
-                        });
-                    }
+            let inputValuesFlat = inputValues.flat();
+            let result = await measureBlock(async function locker_runApp() {
+                return config.runMover({
+                    values: inputValuesFlat,
+                    authority,
+                    snapshotTime: minThreshold,
                 });
+            }, `locker_app_${config.runMover.name}`);
+            if (result.newValues === "abort") {
+                lastAborted = true;
+                return [];
+            }
 
-                for (let [authorityDir, values] of floatingValues) {
-                    await addValues(authorityDir, values.flat(), "floating");
+            let transaction: ArchiveTransaction = {
+                createFiles: [],
+                deleteFiles: mutatedFiles,
+            };
+            const addValues = measureWrap(async function locker_addValues(dir: string, values: PathValue[], key: string) {
+                let split = splitValuesBelowLimit({
+                    values,
+                    maxFileValueCount,
+                    maxFileByteCount,
+                });
+                outputFiles += split.length;
+                outputValueCount += values.length;
+                for (let splitValue of split) {
+                    let dataObj = await pathValueArchives.encodeValuePaths(splitValue.values, {
+                        pathOverrides: {
+                            sourceType: config.outputType,
+                        },
+                    });
+                    if (!dataObj) continue;
+                    outputBytes += dataObj.data.byteLength;
+                    let fileName = pathValueArchives.encodeDataPath({
+                        ...pathValueArchives.getDefaultValuePathInput(),
+                        valueCount: splitValue.values.length,
+                        byteCount: dataObj.data.byteLength,
+                        minTime: splitValue.minTime,
+                        maxTime: splitValue.maxTime,
+                        sourceType: config.outputType,
+                        misc: key,
+                    });
+                    transaction.createFiles.push({
+                        data: dataObj.data,
+                        file: dir + fileName,
+                    });
                 }
+            });
 
-                for (let key in result.newValues) {
-                    let values = result.newValues[key];
-                    await addValues(authorityDir, values, key);
-                }
+            for (let [authorityDir, values] of floatingValues) {
+                await addValues(authorityDir, values.flat(), "floating");
+            }
 
-                if (!config.force && !meetsThreshold({ inputFiles, inputBytes, outputFiles, outputBytes })) {
-                    abortedDueToInsufficientReduction = true;
-                    return [];
-                }
 
-                lastFileWrites.set(lastWriteHash, transaction.createFiles.map(x => x.file));
+            for (let [key, values] of Object.entries(result.newValues)) {
+                let targets = PathRouter.getSelfPathIdentifierTargets(values);
+                for (let [target, values] of targets) {
+                    await addValues(target + "/", values, key);
+                }
+            }
 
-                return [transaction];
-            });
-            if (lastAborted) {
-                lastResult = "aborted";
+            if (!config.force && !meetsThreshold({ inputFiles, inputBytes, outputFiles, outputBytes })) {
+                abortedDueToInsufficientReduction = true;
+                return [];
             }
+
+            return [transaction];
+        });
+        if (lastAborted) {
+            lastResult = "aborted";
         }
-        let time = Date.now() - startTime;
-        let resultFormat = (
-            lastResult === "accepted" && green("accepted")
-            || lastResult === "aborted" && green("noop")
-            || red("rejected")
+    }
+    let time = Date.now() - startTime;
+    let resultFormat = (
+        lastResult === "accepted" && green("accepted")
+        || lastResult === "aborted" && green("noop")
+        || red("rejected")
+    );
+    console.log(`ArchiveMover ${config.debugName ?? config.runMover.name} in ${formatTime(time)}. Result = ${resultFormat}.`);
+    if (lastResult === "accepted" && !abortedDueToInsufficientReduction) {
+        console.log(
+            `ArchiveMover free committed ${config.debugName ?? config.runMover.name}`
+            + `    { files: ${formatNumber(inputFiles)}, values: ${formatNumber(inputValueCount)}, bytes: ${formatNumber(inputBytes)} }`
+            + "\n=>\n"
+            + `    { files: ${formatNumber(outputFiles)}, values: ${formatNumber(outputValueCount)}, bytes: ${formatNumber(outputBytes)} }`
+            ,
+            {
+                inputFiles,
+                outputBytes,
+                authority,
+            }
         );
-        console.log(`ArchiveMover ${config.debugName ?? config.runMover.name} on ${authorityDir} in ${formatTime(time)}. Result = ${resultFormat}.`);
-        if (lastResult === "accepted" && !abortedDueToInsufficientReduction) {
-            console.log(
-                `ArchiveMover free committed ${config.debugName ?? config.runMover.name} on ${authorityDir}`
-                + `    { files: ${formatNumber(inputFiles)}, values: ${formatNumber(inputValueCount)}, bytes: ${formatNumber(inputBytes)} }`
-                + "\n=>\n"
-                + `    { files: ${formatNumber(outputFiles)}, values: ${formatNumber(outputValueCount)}, bytes: ${formatNumber(outputBytes)} }`
-                ,
-                {
-                    inputFiles,
-                    outputBytes,
-                }
-            );
-            logNodeStats("archives|Input Files", formatNumber, time);
-            logNodeStats("archives|Input Values", formatNumber, time);
-            logNodeStats("archives|Input Bytes", formatNumber, time);
-            logNodeStats("archives|Output Files", formatNumber, time);
-            logNodeStats("archives|Output Values", formatNumber, time);
-            logNodeStats("archives|Output Bytes", formatNumber, time);
-        }
-        console.log(" ");
+        logNodeStats("archives|Input Files", formatNumber, time);
+        logNodeStats("archives|Input Values", formatNumber, time);
+        logNodeStats("archives|Input Bytes", formatNumber, time);
+        logNodeStats("archives|Output Files", formatNumber, time);
+        logNodeStats("archives|Output Values", formatNumber, time);
+        logNodeStats("archives|Output Bytes", formatNumber, time);
     }
+    console.log(" ");
 }
 
 const splitValuesBelowLimit = measureWrap(function splitValuesBelowLimit(config: {

package/src/2-proxy/garbageCollection.ts

@@ -2,10 +2,9 @@ import { delay } from "socket-function/src/batching";
 import { cache, lazy } from "socket-function/src/caching";
 import { formatNumber } from "socket-function/src/formatting/format";
 import { magenta, blue, red, green, yellow } from "socket-function/src/formatting/logColors";
-import { nextId, sort, binarySearchBasic, timeInDay } from "socket-function/src/misc";
+import { nextId, sort, binarySearchBasic, timeInDay, timeInMinute } from "socket-function/src/misc";
 import { measureWrap } from "socket-function/src/profiling/measure";
 import { canHaveChildren } from "socket-function/src/types";
-import { AuthorityPath, pathValueAuthority2 } from "../0-path-value-core/NodePathAuthorities";
 import { pathValueCommitter } from "../0-path-value-core/PathValueCommitter";
 import { ReadLock, epochTime, PathValue, authorityStorage, compareTime, getNextTime } from "../0-path-value-core/pathValueCore";
 import { WatchSpec, clientWatcher } from "../1-path-client/pathValueClientWatcher";
@@ -19,6 +18,7 @@ import { runArchiveMover } from "./archiveMoveHarness";
 import { getStorageDir, getSubFolder } from "../fs";
 import fs from "fs";
 import { sha256 } from "js-sha256";
+import { AuthoritySpec, PathRouter } from "../0-path-value-core/PathRouter";
 
 
 export interface AliveChecker<T = unknown> {
@@ -235,7 +235,7 @@ function sandboxedIsAlive(config: {
     pathStr: string;
     path: string[];
     checker: AliveChecker;
-    authority: AuthorityPath;
+    authority: AuthoritySpec;
     unsyncedPaths: Map<AliveChecker, Map<string, {
         paths: Set<string>;
         parentPaths: Set<string>;
@@ -286,13 +286,13 @@ function sandboxedIsAlive(config: {
 
     for (let path of evalResult.pathsRead) {
         if (authorityStorage.isSynced(path)) continue;
-        if (!pathValueAuthority2.isInAuthority(authority, path)) {
+        if (!PathRouter.matchesAuthoritySpec(authority, path)) {
             getObj().paths.add(path);
         }
     }
     for (let path of evalResult.parentPathsRead) {
         if (authorityStorage.isParentSynced(path)) continue;
-        if (!pathValueAuthority2.isInAuthority(authority, path)) {
+        if (!PathRouter.matchesAuthoritySpec(authority, path)) {
             getObj().parentPaths.add(path);
         }
     }
@@ -324,7 +324,7 @@ const runAliveCheckerIterationBase = measureWrap(function runAliveCheckerIterati
     checkPaths: Map<PathSelector, string[][]>;
     selectors: Map<PathSelector, AliveChecker>;
     useLocks: boolean;
-    authority: AuthorityPath;
+    authority: AuthoritySpec;
     getValues: (path: string, parts: string[]) => PathValue[];
     unsyncedPaths: Map<AliveChecker, Map<string, {
         paths: Set<string>;
@@ -648,7 +648,7 @@ export async function runAliveCheckerIteration(config?: {
                             parentPaths,
                             promiseObj: wait,
                         };
-                        await Promise.race([delay(15000), wait.promise]);
+                        await Promise.race([delay(timeInMinute), wait.promise]);
                     }
                     {
                         let totalFreeCount = 0;
@@ -697,6 +697,7 @@ export async function runAliveCheckerIteration(config?: {
                                     lockCount++;
                                 }
                                 for (let free of freeList) {
+                                    // NOTE: I recently changed this so it sets it to be an event, so it doesn't write it to the disk, and it clears it out of memory. This should be a lot more efficient because instead of deleting it from disk and then adding it back to disk and then having it cleaned up when we compress the archives on disk, we can just remove it from disk and never write it back to disk. But all the authorities will have the updated in-memory versions. 
                                     lockWrites.push({
                                         path: free.value.path,
                                         time,
@@ -706,7 +707,7 @@ export async function runAliveCheckerIteration(config?: {
                                         isValueLazy: false,
 
                                         canGCValue: true,
-                                        event: undefined,
+                                        event: true,
                                         isTransparent: true,
                                         valid: true,
                                         source: undefined,