querysub 0.402.0 → 0.404.0

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

@@ -1,37 +1,34 @@
-import debugbreak from "debugbreak";
 import { SocketFunction } from "socket-function/SocketFunction";
-import { cache, cacheArgsEqual, lazy } from "socket-function/src/caching";
-import { addEpsilons, getBufferFraction, minusEpsilon } from "../bits";
-import { errorToUndefined, ignoreErrors, logErrors } from "../errors";
-import { appendToPathStr, getParentPathStr, getPathDepth, getPathFromStr, getPathIndexAssert, getPathStr, hack_getPackedPathSuffix, hack_setPackedPathSuffix, hack_stripPackedPath, removePathLastPart, rootPathStr } from "../path";
-import { measureBlock, measureFnc, measureWrap } from "socket-function/src/profiling/measure";
-import { IdentityController_getOwnPubKeyShort, debugNodeId, debugNodeThread } from "../-c-identity/IdentityController";
+import { lazy } from "socket-function/src/caching";
+import { addEpsilons, minusEpsilon } from "../bits";
+import { logErrors } from "../errors";
+import { appendToPathStr, getParentPathStr, getPathDepth, getPathIndexAssert, hack_getPackedPathSuffix, hack_setPackedPathSuffix, hack_stripPackedPath } from "../path";
+import { measureFnc, measureWrap } from "socket-function/src/profiling/measure";
+import { IdentityController_getOwnPubKeyShort } from "../-c-identity/IdentityController";
 import { pathValueArchives } from "./pathValueArchives";
-import { blue, magenta, red, yellow } from "socket-function/src/formatting/logColors";
-import { PathValueController, pathValueCommitter } from "./PathValueController";
-import { batchFunction, delay, runInfinitePoll } from "socket-function/src/batching";
-import { ActionsHistory } from "../diagnostics/ActionsHistory";
-import { markArrayAsSplitable } from "socket-function/src/fixLargeNetworkCalls";
-import { registerDynamicResource, registerMapArrayResource, registerResource } from "../diagnostics/trackResources";
-import { binarySearchIndex, isNode, isNodeTrue, last, promiseObj, sort, timeInHour, timeInMinute, timeInSecond, QueueLimited } from "socket-function/src/misc";
-import { isNodeTrusted, isTrusted, isTrustedByNode } from "../-d-trust/NetworkTrust2";
-import { AuthorityPath, LOCAL_DOMAIN, LOCAL_DOMAIN_PATH, pathValueAuthority2 } from "./NodePathAuthorities";
+import { blue } from "socket-function/src/formatting/logColors";
+import { delay, runInfinitePoll } from "socket-function/src/batching";
+import { registerMapArrayResource, registerResource } from "../diagnostics/trackResources";
+import { isNode, isNodeTrue, sort, timeInMinute, timeInSecond } from "socket-function/src/misc";
 import { pathValueSerializer } from "../-h-path-value-serialize/PathValueSerializer";
+import { AuthoritySpec, PathRouter } from "./PathRouter";
 import { formatTime } from "socket-function/src/formatting/format";
-import { getOwnNodeId, isOwnNodeId } from "../-f-node-discovery/NodeDiscovery";
-import { getNodeIdDomain, getNodeIdDomainMaybeUndefined, getNodeIdIP } from "socket-function/src/nodeCache";
-import { getMachineId } from "../-a-auth/certs";
+import { isOwnNodeId } from "../-f-node-discovery/NodeDiscovery";
 import { PromiseRace } from "../../src/misc/PromiseRace";
 
 import yargs from "yargs";
-import { sha256 } from "js-sha256";
 import { PromiseObj } from "../promise";
-import { ClientWatcher } from "../1-path-client/pathValueClientWatcher";
 import { auditLog, isDebugLogEnabled } from "./auditLogs";
-import { logDisk } from "../diagnostics/logs/diskLogger";
-import { isDiskAudit } from "../config";
-
-
+import { ellipsisMiddle } from "../misc";
+import { fastHash } from "../misc/hash";
+import { authorityLookup } from "./AuthorityLookup";
+import { onPathInteracted } from "../diagnostics/pathAuditerCallback";
+import { filterChildPathsBase } from "./hackedPackedPathParentFiltering";
+
+setImmediate(async () => {
+    // Import everything will dynamically import, so the client side can tell that it's required. 
+    await import("./PathWatcher");
+});
 let yargObj = isNodeTrue() && yargs(process.argv)
     .option("noarchive", { type: "boolean", alias: ["noarchives"], desc: "Don't save writes to disk. Still reads from disk." })
     .argv || {}
@@ -71,6 +68,7 @@ export const CLIENTSIDE_PREDICT_LEEWAY = 500;
  *      to write well before this time.
  *      - This has to be at least MAX_CHANGE_AGE * 4.5 + the time to serialize and
  *          send our data to remote storage.
+ *  TODO: Shouldn't this be MAX_TIME_UNTIL_DISK_FLUSH, which properly takes into account the parts (and adds a buffer)
  */
 export const ARCHIVE_FLUSH_LIMIT = Math.max(MAX_CHANGE_AGE * 10, timeInMinute * 60);
 
@@ -96,6 +94,17 @@ export const UNDEFINED_MEMORY_CLEANUP_DELAY = MAX_CHANGE_AGE * 2;
 
 export const ARCHIVE_LOOP_DELAY = MAX_CHANGE_AGE * 2;
 
+export const MIN_WAIT_TIME_UNTIL_DISK_FLUSH = MAX_CHANGE_AGE * 2;
+export const RAND_ADD_TIME_UNTIL_DISK_FLUSH = MAX_CHANGE_AGE * 0.5;
+
+export const MAX_TIME_UNTIL_DISK_FLUSH = (
+    ARCHIVE_LOOP_DELAY
+    + MIN_WAIT_TIME_UNTIL_DISK_FLUSH
+    + RAND_ADD_TIME_UNTIL_DISK_FLUSH
+    // Plus, add a lot of buffer time
+    + MAX_CHANGE_AGE * 5
+);
+
 /** Both of these are just targets, we might exceed them. */
 export const FILE_VALUE_COUNT_LIMIT = 50_000;
 export const FILE_SIZE_LIMIT = 50_000_000;
@@ -143,6 +152,10 @@ export type Time = {
 export const epochTime: Time = { time: 0, version: 0, creatorId: 0 };
 Object.freeze(epochTime);
 
+export function createMissingEpochValue(path: string): PathValue {
+    return { path, value: undefined, canGCValue: true, isTransparent: true, valid: true, time: epochTime, locks: [], lockCount: 0, event: false };
+}
+
 /** `timeMinusEpsilon(time)` < time BUT, there is never a case where
  *      `timeMinusEpsilon(time) < otherTime < time` (there is no gap between the times)
  */
@@ -183,13 +196,6 @@ export type ReadLock = {
     //  is pretty big anyways, but... eh...). HOWEVER, sending if we are reading
     //  undefined is useful, and makes garbage collection possible.
     readIsTransparent: boolean;
-
-    /** A clientside only value to cause rejected values to be used as valid values for a bit, to fix
-     *      the case where we receive the function evaluation before the replacement values (which is
-     *      actually fairly common, due to how permissions work, so that existing paths are faster,
-     *      but new paths are slower).
-      */
-    keepRejectedUntil?: number;
 };
 // NOTE: WriteState is a pared down PathValue for ReadLocks to consume.
 //  1) This helps keep them separate, as values you read are very different from values
@@ -222,6 +228,9 @@ export type PathValue = {
     path: string;
     /** @deprecated ALWAYS access value using pathValueSerializer.getPathValue(), unless making a shallow copy. */
     value: Value;
+    /** Every Time+path combination will be globally unique. For a transaction all parts will have the same Time.
+     *  PathValues with the same Time MUST HAVE the SAME locks arrays.
+     */
     time: Time;
     /** @deprecated NOT deprecated, just remember when you set this ALWAYS set lockCount, otherwise
      *      valid checking breaks!
@@ -235,12 +244,8 @@ export type PathValue = {
      */
     lockCount: number;
 
-    /** value === undefined
-     *      - MUST be set if value === undefined
-     *      - We only GC values if they aren't eclipsing any values (or if we also remove the values they are eclipsing
-     *          at the same time, in an atomic manner).
-     *      - Makes reading more efficient (so we don't have to worry about lazily reading values), and makes our
-     *          intentions more clear.
+    /** This means that the value is equivalent to having no value, and so we can remove it. This is slightly different than is transparent, which means we can read through the value. Sometimes it's transparent, but it's a special flag, and so we can't GC it. 
+     *      - When canGCValue isTransparent MUST be set (it should be a tri-state, not 2 flags). If you're equivalent to nothing, and nothing is obviously transparent, then you must be transparent.
      */
     canGCValue?: boolean;
 
@@ -269,14 +274,10 @@ export type PathValue = {
     isTransparent?: boolean;
 
 
-    /** Authorities will clobber this, but non-authorities might use this?
-     *      - This is mostly an in-memory value, and not meant for storage or transmission.
-     *  IMPORTANT! The ONLY reason a PathValue can be rejected is if one of it's locks are rejected
-     *      (due to a conflict, or that lock value being rejected itself). See call prediction for
-     *      how this can be done to allow arbitrary rejection (as in, locking a large time range,
-     *      on a unique path, and then writing to that path when we want to cause a rejection).
-     */
-    valid?: boolean;
+    /** This should only be set by ValidStateComputer.computeValidStates. IF you want to change the valid state of something, make a shallow copy, and pass it to pathValueCommitter.ingestValuesAndValidStates()
+     *      - Generally, it only makes sense to be read by that function as well, and code inside of authorityStorage
+     *      - Generally this is whether or not the locks are accepted and have no contention in their ranges. */
+    readonly valid?: boolean;
 
     // #region Serialization Only
 
@@ -296,12 +297,29 @@ export type NodeId = string;
 export type WatchConfig = {
     paths: string[];
     parentPaths: string[];
+    // TODO: This should probably be on a per-path basis. 
+    fullHistory?: boolean;
 };
 
 export type PathValueSnapshot = {
     values: { [path: string]: PathValue[] };
 };
 
+/** NOTE: Oftentimes path values have the exact same read locks, as in the array as triple equals. This can make a lot of code more efficient.  */
+export function byLockGroup(values: PathValue[]): Map<ReadLock[], PathValue[]> {
+    let byLockGroup = new Map<ReadLock[], PathValue[]>();
+    for (let value of values) {
+        let locks = value.locks;
+        if (locks.length === 0) continue;
+        let lockGroup = byLockGroup.get(locks);
+        if (!lockGroup) {
+            lockGroup = [];
+            byLockGroup.set(locks, lockGroup);
+        }
+        lockGroup.push(value);
+    }
+    return byLockGroup;
+}
 
 export function getNextTime(): Time {
     return {
@@ -359,46 +377,12 @@ export function debugPathValuePath(pathValue: { time: Time; path: string }): str
     return `(${debugTime(pathValue.time)}) ${pathValue.path}`;
 }
 export function debugPathValue(pathValue: PathValue, write?: boolean): string {
-    return `${debugPathValuePath(pathValue)} ${write ? "=" : "==="} ${String(pathValueSerializer.getPathValue(pathValue))}`;
+    return `${debugPathValuePath(pathValue)} ${write ? "=" : "==="} ${ellipsisMiddle(String(pathValueSerializer.getPathValue(pathValue)), 200)}`;
 }
 export function debugTime(time: Time): string {
     return `${time.time}[${time.version}]@${time.creatorId.toString().slice(4, 12)}`;
 }
 
-export function filterChildPaths(parentPath: string, packedSuffix: string, paths: Set<string> | undefined) {
-    if (!packedSuffix || !paths) return paths;
-    return filterChildPathsBase(parentPath, packedSuffix, paths);
-}
-
-/** Returns a number between 0 (inclusive) and 1 (exclusive)
- *      - See matchesParentRangeFilter, matchesParentRangeFilterPart, and filterChildPaths.
- *  FOR INTERNAL USE ONLY!
- */
-export function __getRoutingHash(key: string): number {
-    let hash = sha256(key);
-    return getBufferFraction(Buffer.from(hash, "hex"));
-}
-// NOTE: Assumes fullPath is already a child of parentPath, and only checks for hash
-export function matchesParentRangeFilter(config: {
-    parentPath: string;
-    fullPath: string;
-    start: number;
-    end: number;
-}) {
-    if (config.start === 0 && config.end === 1) return true;
-    let part = getPathIndexAssert(config.fullPath, getPathDepth(config.parentPath));
-    let hash = __getRoutingHash(part);
-    return config.start <= hash && hash < config.end;
-}
-export function matchesParentRangeFilterPart(config: {
-    part: string;
-    start: number;
-    end: number;
-}) {
-    if (config.start === 0 && config.end === 1) return true;
-    let hash = __getRoutingHash(config.part);
-    return config.start <= hash && hash < config.end;
-}
 
 let getCompressNetworkBase = () => false;
 export const registerGetCompressNetwork = (fnc: () => boolean) => { getCompressNetworkBase = fnc; };
@@ -407,41 +391,6 @@ export function getCompressNetwork() {
 }
 
 
-const filterChildPathsBase = measureWrap(
-    function filterChildPathsBase(parentPath: string, packedSuffix: string, paths: Set<string>): Set<string> {
-        let [startFractionStr, endFractionStr] = packedSuffix.split("|");
-        let startFraction = Number(startFractionStr);
-        let endFraction = Number(endFractionStr);
-
-        let depth = getPathDepth(parentPath);
-
-        let filtered = new Set<string>();
-        for (let path of paths) {
-            let key = getPathIndexAssert(path, depth);
-            let hash = __getRoutingHash(key);
-            if (startFraction <= hash && hash < endFraction) {
-                filtered.add(path);
-            }
-        }
-        //console.log(`Filtered ${paths.size} paths to ${filtered.size} paths`);
-        return filtered;
-    }
-);
-export function encodeParentFilter(config: {
-    path: string;
-    startFraction: number;
-    endFraction: number;
-}) {
-    return hack_setPackedPathSuffix(config.path, `${config.startFraction}|${config.endFraction}`);
-}
-export function decodeParentFilter(path: string): { start: number, end: number } | undefined {
-    let packedSuffix = hack_getPackedPathSuffix(path);
-    if (!packedSuffix) return undefined;
-    let [startStr, endStr] = packedSuffix.split("|");
-    return { start: Number(startStr), end: Number(endStr) };
-
-}
-
 class AuthorityPathValueStorage {
     // path => sorted by -time (so newest are first)
     //  NOTE: We automatically drop historical values that can no longer influence
@@ -496,6 +445,9 @@ class AuthorityPathValueStorage {
         time?: Time,
         readInvalid = false
     ): PathValue | undefined {
+        if (!this.isEventPath(path)) {
+            onPathInteracted(path, 0);
+        }
         let overrideValue: PathValue | undefined;
         if (this.overrides.size > 0) {
             for (let override of this.overrides) {
@@ -535,19 +487,18 @@ class AuthorityPathValueStorage {
         }
         return undefined;
     }
-    public getValuePlusHistory(path: string, returnInvalid = false): PathValue[] {
+    /** Returns all values valid or invalid. You should check the valid flag if you want to know if it's valid.
+     *      - Almost every listener wants this for the purposes of doing validation, and therefore they will want to know if values are invalid, as invalid values can cause another value to become invalid or valid.
+     * sorted by -time (so newest are first)
+     */
+    public getValuePlusHistory(path: string): PathValue[] {
+        if (!this.isEventPath(path)) {
+            onPathInteracted(path, 0);
+        }
         if (this.overrides.size > 0) {
             throw new Error(`AuthorityPathValueStorage.getValuePlusHistory support for temporaryOverride not implemented yet.`);
         }
-        let valuesToReturn: PathValue[] = [];
-        let values = this.values.get(path);
-        if (values) {
-            for (let value of values) {
-                if (!value.valid && !returnInvalid) continue;
-                valuesToReturn.push(value);
-            }
-        }
-        return valuesToReturn;
+        return this.values.get(path) || [];
     }
 
     // TODO: Optimize this via an index
@@ -560,8 +511,11 @@ class AuthorityPathValueStorage {
     public getPathsFromParent(parentPath: string): Set<string> | undefined {
         let packedSuffix = hack_getPackedPathSuffix(parentPath);
         parentPath = hack_stripPackedPath(parentPath);
-        let result = this.parentPathLookup.get(parentPath);
-        return filterChildPaths(parentPath, packedSuffix, result);
+        let paths = this.parentPathLookup.get(parentPath);
+        if (packedSuffix && paths) {
+            paths = filterChildPathsBase(parentPath, packedSuffix, paths);
+        }
+        return paths;
     }
 
     @measureFnc
@@ -583,7 +537,7 @@ class AuthorityPathValueStorage {
         //  1) Need to maintain the values for other nodes
         //  2) Don't need to worry about the values getting out of date,
         //      because we will get any new values whether we want to or not!
-        if (pathValueAuthority2.isSelfAuthority(path)) return;
+        if (PathRouter.isSelfAuthority(path)) return;
 
         if (this.DEBUG_UNWATCH) {
             console.log(blue(`Unsyncing path at ${Date.now()}`), path);
@@ -591,7 +545,6 @@ class AuthorityPathValueStorage {
 
         this.isSyncedCache.delete(path);
         this.removePathFromStorage(path, "unwatched");
-        writeValidStorage.deleteRemovedPath(path);
     }
     public markParentPathAsUnwatched(path: string) {
         // NOTE: I don't think we have to handle the case where we are the authority,
@@ -615,73 +568,6 @@ class AuthorityPathValueStorage {
         return time;
     }
 
-
-    @measureFnc
-    public async getSnapshot(authority: AuthorityPath): Promise<PathValueSnapshot> {
-        let snapshot: PathValueSnapshot = {
-            values: Object.create(null),
-        };
-        let now = Date.now();
-        let count = 0;
-        for (let [path, values] of this.values) {
-            count++;
-            if (count > 10_000) {
-                await delay("paintLoop");
-                count = 0;
-            }
-            // NOTE: We can't return extra values, as they might be outdated values which were
-            //  set to undefined, and then deleted, so returning them will create spurious values.
-            if (!pathValueAuthority2.isInAuthority(authority, path)) continue;
-            this.clearRedundantOldValues(values, now);
-            if (values.length === 0) continue;
-            snapshot.values[path] = values;
-        }
-        return snapshot;
-    }
-    @measureFnc
-    public ingestSnapshot(snapshot: PathValueSnapshot) {
-        // NOTE: It is important that we don't try to archive these values, as they either came
-        //  from the archive, or have already been archived.
-
-        let now = Date.now();
-
-        for (let [path, values] of Object.entries(snapshot.values)) {
-            let existingValues = this.values.get(path);
-            for (let value of values) {
-                if (value.canGCValue) {
-                    this.possiblyUndefinedPaths().value.add(value.path);
-                }
-                if (value.event) {
-                    this.eventPaths().value.add(value.path);
-                }
-            }
-            if (!existingValues) {
-                this.values.set(path, values);
-                this.addParentPath(path);
-            } else {
-                let allValues = existingValues.concat(values);
-                allValues.sort((a, b) => compareTime(b.time, a.time));
-                // Remove duplicates
-                for (let i = 0; i < allValues.length - 1; i++) {
-                    if (allValues[i].time.time === allValues[i + 1].time.time &&
-                        allValues[i].time.creatorId === allValues[i + 1].time.creatorId) {
-                        allValues.splice(i, 1);
-                        i--;
-                    }
-                }
-                values = allValues;
-            }
-            this.clearRedundantOldValues(values, now);
-        }
-    }
-
-    public resetForInitialTrigger(path: string) {
-        if (isDebugLogEnabled()) {
-            auditLog("REMOVE FOR INITIAL SYNC", { path });
-        }
-        this.removePathFromStorage(path, "reset for initial trigger");
-    }
-
     public DEBUG_hasAnyValues(path: string) {
         let values = this.values.get(path);
         if (!values) return false;
@@ -691,7 +577,7 @@ class AuthorityPathValueStorage {
         return true;
     }
     public isSynced(path: string, ignoreParentSync = false) {
-        if (pathValueAuthority2.isSelfAuthority(path)) return true;
+        if (PathRouter.isSelfAuthority(path)) return true;
 
         if (this.isSyncedCache.has(path)) return true;
 
@@ -718,54 +604,69 @@ class AuthorityPathValueStorage {
     }
     public isParentSynced(path: string) {
         // We have to check a test child path to see if we are a self authority
-        if (pathValueAuthority2.isSelfAuthority(appendToPathStr(path, ""))) return true;
+        if (PathRouter.isSelfAuthority(appendToPathStr(path, ""))) return true;
 
         return this.parentsSynced.get(path) === true;
     }
 
+    /** Obviously just for debugging. Doesn't trigger any watchers, just erases it as if we never had it. There shouldn't be really any downstream caches within the same process at least, and so this should result in the next read having the value missing. If we in the future add downstream caches, we're going to have to invalidate them as well.
+            - This is for testing synchronization issues cross process. As any cross-process notifications might be lost. However, internally, we can verify with one hundred percent certainty, if our code is correct, that all of our internal lookups and caching is always in sync. 
+     */
+    public async DEBUG_secretlyDeleteAllValuesWithPath(path: string) {
+        this.values.delete(path);
+        this.lastDeleteAt.delete(path);
+        this.lastDeleteAtOld.delete(path);
+        this.lastDeleteAtOlder.delete(path);
+        // Actually, we don't want to delete it from the isSynced cache, as we still want the path to be considered synchronized. We just want the values to be wrong, as in missing values. 
+        // this.parentsSynced.delete(path);
+        // this.isSyncedCache.delete(path);
+    }
+
     private getMultiNodesForParent: (path: string) => Map<string, unknown> | undefined = () => undefined;
     public setGetMultiNodesForParent(fnc: (path: string) => Map<string, unknown> | undefined) {
         this.getMultiNodesForParent = fnc;
     }
+
+    public addParentSyncs(parentSyncs: { parentPath: string; sourceNodeId: string }[]) {
+
+        for (let obj of parentSyncs) {
+            let parentPath = obj.parentPath;
+            let sourceNodeId = obj.sourceNodeId;
+            let prevSynced = this.parentsSynced.get(parentPath);
+            if (prevSynced === true) continue;
+            let remoteNodeIds = this.getMultiNodesForParent(parentPath);
+            // NOTE: If there is only 1 authority, assume we received data from it, as who else would we receive it from?
+            if (!remoteNodeIds || remoteNodeIds.size === 1) {
+                this.parentsSynced.set(parentPath, true);
+            } else {
+                if (!prevSynced) {
+                    prevSynced = new Set(remoteNodeIds.keys());
+                    this.parentsSynced.set(parentPath, prevSynced);
+                }
+                prevSynced.delete(sourceNodeId);
+                if (prevSynced.size === 0) {
+                    this.parentsSynced.set(parentPath, true);
+                }
+            }
+        }
+    }
+
+    /** @deprecated Should only be called by ValidStateComputer. Otherwise, the valid states can change and it won't be able to detect them, and so triggering nested dependencies will not work.  */
     @measureFnc
     public ingestValues(
         newValues: PathValue[],
-        parentsSynced: string[] | undefined,
-        parentSyncedSources: Map<string, string[]> | undefined,
-        // Skips archiving (used if we received the values from another node, in which case
-        //  not only should the values already be archives, they are likely too old to be archives
-        //  again!)
-        skipArchive?: "skipArchive"
+        config?: { doNotArchive?: boolean },
     ) {
+        for (let value of newValues) {
+            if (value.event) continue;
+            onPathInteracted(value.path, 1);
+        }
+        let { doNotArchive } = config ?? {};
         let now = Date.now();
 
-        if (isDebugLogEnabled()) {
+        if (isDebugLogEnabled() && !config?.doNotArchive) {
             for (let value of newValues) {
-                auditLog("INGEST VALUE", { path: value.path, time: value.time.time });
-            }
-        }
-
-        if (parentsSynced) {
-            for (let parentPath of parentsSynced) {
-                let prevSynced = this.parentsSynced.get(parentPath);
-                if (prevSynced === true) continue;
-                let remoteNodeIds = this.getMultiNodesForParent(parentPath);
-                let sourceNodeIds = parentSyncedSources?.get(parentPath);
-                // NOTE: If there is only 1 authority, assume we received data from it, as who else would we receive it from?
-                if (!remoteNodeIds || remoteNodeIds.size === 1 || !sourceNodeIds) {
-                    this.parentsSynced.set(parentPath, true);
-                } else {
-                    if (!prevSynced) {
-                        prevSynced = new Set(remoteNodeIds.keys());
-                        this.parentsSynced.set(parentPath, prevSynced);
-                    }
-                    for (let sourceNodeId of sourceNodeIds) {
-                        prevSynced.delete(sourceNodeId);
-                    }
-                    if (prevSynced.size === 0) {
-                        this.parentsSynced.set(parentPath, true);
-                    }
-                }
+                auditLog("INGEST VALUE", { path: value.path, timeId: value.time.time });
             }
         }
 
@@ -778,27 +679,13 @@ class AuthorityPathValueStorage {
                 this.possiblyUndefinedPaths().value.add(value.path);
             }
 
-            if (!skipArchive && !value.event && !value.path.startsWith(LOCAL_DOMAIN_PATH)) {
-                let authorityPath = pathValueAuthority2.getSelfArchiveAuthority(value.path);
-
-                // Store in pending archive lookup
-                if (authorityPath) {
-                    let values = this.pendingArchiveValues.get(authorityPath);
-                    if (!values) {
-                        values = [];
-                        this.pendingArchiveValues.set(authorityPath, values);
-                    }
-                    // If our value has no locks it can never be rejected, so if it is the latest, don't bother to keep the others
-                    if (value.lockCount === 0 && values.length > 0 && values.every(x => compareTime(x.time, value.time) < 0)) {
-                        validateLockCount(value);
-                        if (values.length > 1) {
-                            values.splice(1, values.length - 1);
-                        }
-                        values[0] = value;
-                    } else {
-                        values.push(value);
-                    }
+            if (!doNotArchive && !value.event && !PathRouter.isLocalPath(value.path) && PathRouter.isSelfAuthority(value.path)) {
+                let values = this.pendingArchiveValues.get(value.path);
+                if (!values) {
+                    values = [];
+                    this.pendingArchiveValues.set(value.path, values);
                 }
+                values.push(value);
             }
 
             // Store in global lookup
@@ -816,13 +703,15 @@ class AuthorityPathValueStorage {
                 } else {
                     let prev = values[insertIndex];
                     if (prev && compareTime(prev.time, value.time) === 0) {
+                        // NOTE: Before, we used to try to just update the valid state. However, it's kind of unsafe to do this as it results in mutating values, which could make our committer miss a valid state change. Assignment should be just as good. 
+                        values[insertIndex] = value;
                         // Just update the valid state (we likely aren't an authority on the path anyways)
-                        prev.valid = value.valid;
+                        //prev.valid = value.valid;
                     } else {
                         // Special case values that always have no locks, by just setting the value, and never splicing
                         if (insertIndex === 0 && value.lockCount === 0 && values.length <= 1) {
                             validateLockCount(value);
-                            if (!isCoreQuiet) {
+                            if (!isCoreQuiet && !doNotArchive) {
                                 if (values.length === 1) {
                                     console.log(`Clobbering ${debugPathValuePath(values[0])} with ${debugPathValuePath(value)}`);
                                 }
@@ -835,7 +724,7 @@ class AuthorityPathValueStorage {
                     }
                 }
                 if (!specialGoldenCase) {
-                    this.clearRedundantOldValues(values, now);
+                    this.clearRedundantOldValues(values, now, doNotArchive);
                 }
             }
         }
@@ -850,8 +739,8 @@ class AuthorityPathValueStorage {
         this.archiveLoop();
     }
 
-    // authorityPath => values
-    private pendingArchiveValues = registerMapArrayResource("pendingArchiveValues", new Map<AuthorityPath, PathValue[]>());
+    // path => values
+    private pendingArchiveValues = registerMapArrayResource("pendingArchiveValues", new Map<string, PathValue[]>());
     private shuttingDown = new PromiseObj<"shutdown">();
     private pendingShutdownWrites: PromiseObj | undefined;
 
@@ -875,7 +764,7 @@ class AuthorityPathValueStorage {
         // Wait long enough for all values to be old enough to have a fixed valid state.
         // Also wait some extra time randomly, to reduce the chances of archive being
         //  called at the same time on multiple nodes at once.
-        let delayTime = MAX_CHANGE_AGE * 2 + Math.random() * MAX_CHANGE_AGE * 0.5;
+        let delayTime = MIN_WAIT_TIME_UNTIL_DISK_FLUSH + Math.random() * RAND_ADD_TIME_UNTIL_DISK_FLUSH;
         if (this.shuttingDown.resolved) {
             delayTime = 0;
         }
@@ -890,14 +779,16 @@ class AuthorityPathValueStorage {
         }
 
         try {
-            for (let [authorityPath, allValues] of pending) {
-                let validValues = allValues
-                    .filter(x => x.valid)
-                    // ALSO, don't archive epochTime values...
-                    .filter(x => x.time.time)
-                    ;
-                await pathValueArchives.archiveValues(authorityPath, validValues);
-            }
+            // Only take the valid values, and only the latest. We don't need the history, because these values are all old enough that they can't be rejected (And any one that is referencing the non-latest value, by definition, has to be older than that, and therefore old enough that it can also no longer be rejected)
+            let finalValues: PathValue[] = [];
+            for (let values of pending.values()) {
+                // Valid, and not epoch time
+                values = values.filter(x => x.valid && x.time.time);
+                if (values.length === 0) continue;
+                values.sort((a, b) => compareTime(b.time, a.time));
+                finalValues.push(values[0]);
+            }
+            await pathValueArchives.archiveValues(finalValues);
         } finally {
             this.pendingShutdownWrites?.resolve();
         }
@@ -907,12 +798,11 @@ class AuthorityPathValueStorage {
         if (yargObj.noarchive) return;
         this.shuttingDown.resolve("shutdown");
         if (this.pendingArchiveValues.size === 0) return;
-        await pathValueAuthority2.waitUntilRoutingIsReady();
+        let topology = await authorityLookup.getTopology();
         // If there are other nodes, we CAN'T just archive our values, as some maybe rejected in the future.
-        let nodes = pathValueAuthority2.getReadNodes(rootPathStr);
-        let otherReadNodes = nodes.filter(x => !isOwnNodeId(x));
+        let otherReadNodes = topology.filter(x => !isOwnNodeId(x.nodeId));
         if (otherReadNodes.length > 0 && this.pendingArchiveValues.size > 0) {
-            console.log(`Other authorities (${otherReadNodes.length}), discarding ${this.pendingArchiveValues.size} pending writes`);
+            console.log(`Other authorities (${otherReadNodes.length}), discarding ${this.pendingArchiveValues.size} pending writes`, otherReadNodes, topology.filter(x => isOwnNodeId(x.nodeId)));
         }
         if (otherReadNodes.length === 0) {
             // Wait the PromiseRace to finish
@@ -930,7 +820,7 @@ class AuthorityPathValueStorage {
     //  really happen too often (and the real issue is not moving values from memory => storage, which when we do,
     //  we will call this anyways).
     // NOTE: values are sorted sorted by -time (so newest are first)
-    public clearRedundantOldValues(values: PathValue[], now: number) {
+    public clearRedundantOldValues(values: PathValue[], now: number, doNotArchive?: boolean) {
         // NOTE: We can also delete golden rejections BEFORE the valid golden value. But...
         //  that is less important, as there are likely to be few rejected values, so this
         //  is really just designed for removing older golden values (which are probably valid).
@@ -953,7 +843,7 @@ class AuthorityPathValueStorage {
             && values[0].canGCValue
             && values[0].time.time < now - VALUE_GC_THRESHOLD
         ) {
-            if (!isCoreQuiet) {
+            if (!isCoreQuiet && !doNotArchive) {
                 console.log(`GCing ALL ${debugPathValuePath(values[0])}`);
                 for (let value of values) {
                     auditLog("GCing", { path: value.path });
@@ -977,7 +867,7 @@ class AuthorityPathValueStorage {
         if (firstGoldenIndex === 0) {
             // Remove everything but the latest value
             let removed = values.splice(1, values.length - 1);
-            if (!isCoreQuiet) {
+            if (!isCoreQuiet && !doNotArchive) {
                 console.log(`GCing everything older than ${debugPathValuePath(values[0])}`);
                 for (let value of removed) {
                     auditLog("GCing", { path: value.path });
@@ -988,7 +878,7 @@ class AuthorityPathValueStorage {
             if (firstGoldenIndex >= 0 && values.length > firstGoldenIndex) {
                 for (let i = values.length - 1; i > firstGoldenIndex; i--) {
                     let gced = values.pop();
-                    if (!isCoreQuiet && gced) {
+                    if (!isCoreQuiet && !doNotArchive && gced) {
                         auditLog("GCing", { path: gced.path });
                     }
                 }
@@ -996,7 +886,7 @@ class AuthorityPathValueStorage {
         }
     }
 
-    private removePathFromStorage(path: string, reason: string) {
+    public removePathFromStorage(path: string, reason: string) {
         let values = this.values.get(path);
         if (values?.length) {
             this.lastDeleteAt.set(path, values[0].time);
@@ -1023,7 +913,8 @@ class AuthorityPathValueStorage {
     private possiblyUndefinedPaths = lazy((): { value: Set<string> } => {
         let pathsToCheckPointer = { value: new Set<string>() };
 
-        runInfinitePoll(UNDEFINED_MEMORY_CLEANUP_DELAY, () => {
+        runInfinitePoll(UNDEFINED_MEMORY_CLEANUP_DELAY, async () => {
+            const { pathWatcher } = await import("./PathWatcher");
             let now = Date.now();
             let deadTime = now - UNDEFINED_MEMORY_CLEANUP_DELAY;
             let pathsToCheck = pathsToCheckPointer.value;
@@ -1061,11 +952,16 @@ class AuthorityPathValueStorage {
         return pathsToCheckPointer;
     });
 
+    private isEventPath(path: string) {
+        return this.eventPaths().value.has(path);
+    }
+
     private eventPaths = lazy((): { value: Set<string> } => {
         let pathsToCheckPointer = { value: new Set<string>() };
 
         let garbageCollectTime = MAX_CHANGE_AGE * 2;
-        runInfinitePoll(garbageCollectTime, () => {
+        runInfinitePoll(garbageCollectTime, async () => {
+            const { pathWatcher } = await import("./PathWatcher");
             let deadTime = Date.now() - garbageCollectTime;
             let pathsToCheck = pathsToCheckPointer.value;
             let nextPathsToCheck = new Set<string>();
@@ -1129,1241 +1025,48 @@ class AuthorityPathValueStorage {
     public __auditValues() {
         return this.values;
     }
-}
-export const authorityStorage = new AuthorityPathValueStorage();
-export const values = authorityStorage;
-export const pathValues = authorityStorage;
-
 
-// If PathValue, it is a local watch
-export type WriteCallback = NodeId | PathValue[];
-
-
-// isOwnNodeId(nodeId) means localOnValueCallback is called (instead of PathValueController.forwardWrites)
-export type PathWatcherCallback = NodeId;
-class PathWatcher {
-    private watchers = registerResource("paths|PathWatcher.watchers", new Map<string, {
-        watchers: Set<PathWatcherCallback>;
-        requestedTime: number;
-        receivedTime: number;
-    }>());
-    // A fast way to lookup parentPath => childPaths in watchers, without having
-    //  to brute force search.
-    private watcherParentToPath = registerResource("paths|PathWatcher.watcherParentToPath", new Map<string, Set<string>>());
-    // If we don't limit the length, then this will memory leak. And if we only track
-    //  the values in watchers, then rolling key syncs will be lost.
-    // DOES NOT track local values, as they are used internally, but we aren't waiting for them to be synced.
-    private syncHistoryForHarvest = new QueueLimited<{ start: number; end: number; path: string; }>(1_000_000);
-    private syncHistoryForDebug = new QueueLimited<{ start: number; end: number; path: string; }>(1_000_000);
-
-    //private watchers = registerResource("paths|PathWatcher.watchers", new Map<string, Set<PathWatcherCallback>>());
-
-    // realPath => packedPath => watcher => { depth, start, end }[]
-    private parentWatchers = registerResource("paths|parentWatchers", new Map<string,
-        // packedPath
-        Map<string, {
-            watchers: Set<PathWatcherCallback>;
-            start: number;
-            end: number;
-        }>
-    >());
-    private watchersToPaths = registerResource("paths|watchersToPaths", new Map<PathWatcherCallback, {
-        paths: Set<string>;
-        parents: Set<string>;
-    }>());
-
-    /** Automatically unwatches on callback disconnect */
-    @measureFnc
-    public watchPath(config: WatchConfig & {
-        callback: PathWatcherCallback;
-        debugName?: string;
-        noInitialTrigger?: boolean;
-        /** Force trigger, even if we are already watching the values. */
-        initialTrigger?: boolean;
-    }) {
-        if (config.callback) {
-            this.ensureUnwatchingOnDisconnect(config.callback);
-        }
-
-        let newPathsWatched = new Set<string>();
-        let newParentsWatched = new Set<string>();
-
-        let time = Date.now();
-
-        for (let path of config.paths) {
-            let watchers = this.watchers.get(path);
-            if (!watchers) {
-                watchers = {
-                    watchers: new Set(),
-                    requestedTime: time,
-                    receivedTime: 0,
-                };
-                this.watchers.set(path, watchers);
-                let parentPath = getParentPathStr(path);
-                let parentWatchers = this.watcherParentToPath.get(parentPath);
-                if (!parentWatchers) {
-                    parentWatchers = new Set();
-                    this.watcherParentToPath.set(parentPath, parentWatchers);
-                }
-                parentWatchers.add(path);
-            }
-            if (watchers.watchers.has(config.callback)) continue;
-            newPathsWatched.add(path);
-            watchers.watchers.add(config.callback);
-
-            let watchObj = this.watchersToPaths.get(config.callback);
-            if (!watchObj) {
-                watchObj = { paths: new Set(), parents: new Set() };
-                this.watchersToPaths.set(config.callback, watchObj);
-            }
-            watchObj.paths.add(path);
-        }
-        for (let path of config.parentPaths) {
-            let basePath = hack_stripPackedPath(path);
-            let watchersObj = this.parentWatchers.get(basePath);
-            if (!watchersObj) {
-                watchersObj = new Map();
-                this.parentWatchers.set(basePath, watchersObj);
-            }
-            let obj = watchersObj.get(path);
-            if (!obj) {
-                let range = decodeParentFilter(path) || { start: 0, end: 1 };
-                obj = { watchers: new Set(), start: range.start, end: range.end };
-                watchersObj.set(path, obj);
-            }
-            if (obj.watchers.has(config.callback)) continue;
-            obj.watchers.add(config.callback);
-
-            newParentsWatched.add(path);
-
-            let watchObj = this.watchersToPaths.get(config.callback);
-            if (!watchObj) {
-                watchObj = { paths: new Set(), parents: new Set() };
-                this.watchersToPaths.set(config.callback, watchObj);
-            }
-            watchObj.parents.add(path);
-        }
-
-        if (newPathsWatched.size > 0 || newParentsWatched.size > 0) {
-            if (isOwnNodeId(config.callback)) {
-                for (let path of newPathsWatched) {
-                    auditLog("new local WATCH VALUE", { path });
-                }
-                for (let path of newParentsWatched) {
-                    auditLog("new local WATCH PARENT", { path });
-                }
-            } else {
-                for (let path of newPathsWatched) {
-                    auditLog("new non-local WATCH VALUE", { path, watcher: config.callback });
-                }
-                for (let path of newParentsWatched) {
-                    auditLog("new non-local WATCH PARENT", { path, watcher: config.callback });
-                }
-            }
-            console.info(`New PathValue watches`, {
-                newPathsWatched: newPathsWatched.size,
-                newParentsWatched: newParentsWatched.size,
-            });
-        }
-
-        // Treat everything as a new watch
-        if (config.initialTrigger) {
-            newPathsWatched = new Set(config.paths);
-            newParentsWatched = new Set(config.parentPaths);
-        }
-
-        if (!config.noInitialTrigger) {
-            // Trigger all initial values (for paths we have synced)
-            let initialValues = new Set<PathValue>();
-            let newPaths = new Set(Array.from(newPathsWatched).filter(x => authorityStorage.isSynced(x)));
-            for (let path of newParentsWatched) {
-                // If we haven't synced the parent, we can't forward it. This is important for proxies
-                //  (when they receive the parent synced they will forward the values).
-                if (!authorityStorage.isParentSynced(path)) continue;
-                let paths = authorityStorage.getPathsFromParent(path);
-                if (paths) {
-                    for (let path of paths) {
-                        newPaths.add(path);
-                    }
-                }
-
-                let childPaths = this.watcherParentToPath.get(path);
-                if (childPaths) {
-                    for (let childPath of childPaths) {
-                        newPaths.add(childPath);
-                    }
-                }
-            }
-
-            if (newPaths.size > 0 || newParentsWatched.size > 0) {
-                for (let path of newPaths) {
-                    let history = authorityStorage.getValuePlusHistory(path);
-                    for (let value of history) {
-                        initialValues.add(value);
-                    }
-                    if (history.length === 0) {
-                        // We always have to send something, or the client won't know when they are ready to show the data!
-                        initialValues.add({ path, value: undefined, canGCValue: true, isTransparent: true, valid: true, time: epochTime, locks: [], lockCount: 0, event: false });
-                    }
-                }
-                this.triggerLatestWatcher(
-                    config.callback,
-                    Array.from(initialValues),
-                    config.parentPaths,
-                    config.initialTrigger ? "initialTrigger" : undefined,
-                );
-            }
-        }
-    }
-    // NOTE: Automatically unwatches from remoteWatcher on all paths that are fully unwatched
-    @measureFnc
-    public unwatchPath(config: WatchConfig & { callback: PathWatcherCallback; }) {
-        const { callback } = config;
-
-        let fullyUnwatched: WatchConfig = {
-            paths: [],
-            parentPaths: [],
-        };
-
-        let pathsWatched = this.watchersToPaths.get(callback);
-
-        for (let path of config.parentPaths) {
-            if (pathsWatched) {
-                pathsWatched.parents.delete(path);
-            }
-
-            let unpackedPath = hack_stripPackedPath(path);
-
-            let watchersObj = this.parentWatchers.get(unpackedPath);
-            if (!watchersObj) continue;
-            let obj = watchersObj.get(path);
-            if (!obj) continue;
-            obj.watchers.delete(callback);
-
-            if (isOwnNodeId(callback)) {
-                auditLog("local UNWATCH PARENT", { path });
-            } else {
-                auditLog("non-local UNWATCH PARENT", { path, watcher: callback });
-            }
-
-            if (obj.watchers.size === 0) {
-                watchersObj.delete(path);
-                this.parentWatchers.delete(path);
-                fullyUnwatched.parentPaths.push(path);
-                authorityStorage.markParentPathAsUnwatched(path);
-
-                if (watchersObj.size === 0) {
-                    this.parentWatchers.delete(unpackedPath);
-
-                    let childPaths = authorityStorage.getPathsFromParent(unpackedPath);
-                    // Destroy values that now have no watchers (no value watchers, and now no parent watcher
-                    if (childPaths) {
-                        for (let childPath of childPaths) {
-                            if (!this.watchers.has(childPath)) {
-                                authorityStorage.destroyPath(childPath);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        // NOTE: Unwatch parents, then values, as parent paths might keep alive value path watches.
-        for (let path of config.paths) {
-            if (pathsWatched) {
-                pathsWatched.paths.delete(path);
-            }
-
-            let watchers = this.watchers.get(path);
-            if (!watchers) continue;
-            watchers.watchers.delete(callback);
-
-            if (isOwnNodeId(callback)) {
-                auditLog("local UNWATCH VALUE", { path });
-            } else {
-                auditLog("non-local UNWATCH VALUE", { path, watcher: callback });
-            }
-
-            if (watchers.watchers.size === 0) {
-                this.watchers.delete(path);
-
-                let parentPath = getParentPathStr(path);
-                let parentWatchers = this.watcherParentToPath.get(parentPath);
-                if (parentWatchers) {
-                    parentWatchers.delete(path);
-                }
-
-                fullyUnwatched.paths.push(path);
-                // NOTE: If the parent is being watched, don't destroy the value.
-                //  - The fact that we only do the check here does mean that if the path is unwatched
-                //      first and then later the parent path is unwatched we will fail to properly destroy
-                //      the path. However, in practice, either both are unwatched at the same time, or more
-                //      likely, the value watch only goes away because it's made redundant by the parent watch.
-                if (!this.parentWatchers.has(parentPath)) {
-                    authorityStorage.destroyPath(path);
-                }
-            }
-        }
-
-        if (fullyUnwatched.paths.length > 0 || fullyUnwatched.parentPaths.length > 0) {
-            console.info(`Unwatched PathValue watches`, {
-                unwatchedPaths: fullyUnwatched.paths.length,
-                unwatchedParents: fullyUnwatched.parentPaths.length,
-            });
-            for (let unwatchCallback of this.unwatchedCallbacks) {
-                unwatchCallback(fullyUnwatched);
-            }
+    public getValueCount() {
+        let totalCount = 0;
+        for (let values of this.values.values()) {
+            totalCount += values.length;
         }
+        return totalCount;
     }
 
-    public unwatchEventPaths(paths: Set<string>) {
-        for (let path of paths) {
-            let watchers = this.watchers.get(path);
-            if (watchers) {
-                this.watchers.delete(path);
-                for (let watcher of watchers.watchers) {
-                    let watchObj = this.watchersToPaths.get(watcher);
-                    if (watchObj) {
-                        watchObj.paths.delete(path);
-                    }
-                }
-            }
-            let parentWatchers = this.parentWatchers.get(path);
-            if (parentWatchers) {
-                this.parentWatchers.delete(path);
-                for (let { watchers } of parentWatchers.values()) {
-                    for (let watcher of watchers) {
-                        let watchObj = this.watchersToPaths.get(watcher);
-                        if (watchObj) {
-                            watchObj.parents.delete(path);
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    public triggerValuesChanged(valuesChanged: Set<PathValue>, parentsSynced?: string[], initialTriggers?: { values: Set<string>; parentPaths: Set<string> }) {
-        let changedPerCallbacks = this.getWatchers(valuesChanged, { parentsSynced, pathsAreSynced: true });
-        for (let [watch, changes] of changedPerCallbacks) {
-            if (initialTriggers) {
-                let valuesFromInitialTrigger = new Set<PathValue>();
-                let parentsFromInitialTrigger = new Set<string>();
-                let valuesOther = new Set<PathValue>();
-                let parentsOther = new Set<string>();
-                for (let value of changes) {
-                    if (initialTriggers.values.has(value.path)) {
-                        valuesFromInitialTrigger.add(value);
-                    } else {
-                        valuesOther.add(value);
-                    }
-                }
-                for (let parent of initialTriggers.parentPaths) {
-                    parentsFromInitialTrigger.add(parent);
-                }
-                if (parentsSynced) {
-                    for (let parent of parentsSynced) {
-                        if (!initialTriggers.parentPaths.has(parent)) {
-                            parentsOther.add(parent);
-                        }
-                    }
-                }
-
-                if (valuesFromInitialTrigger.size > 0 || parentsFromInitialTrigger.size > 0) {
-                    this.triggerLatestWatcher(watch, Array.from(valuesFromInitialTrigger), Array.from(parentsFromInitialTrigger), "initialTrigger");
-                }
-                if (valuesOther.size > 0 || parentsOther.size > 0) {
-                    this.triggerLatestWatcher(watch, Array.from(valuesOther), Array.from(parentsOther));
-                }
-            } else {
-                this.triggerLatestWatcher(watch, Array.from(changes), parentsSynced);
-            }
-        }
-    }
-    public getWatchers<T extends { path: string }>(
-        valuesChanged: Set<T>,
-        config?: {
-            parentsSynced?: string[];
-            pathsAreSynced?: boolean;
-        }
-    ) {
-        let changedPerCallbacks: Map<PathWatcherCallback, Set<T>> = new Map();
-        let time = Date.now();
-        for (let value of valuesChanged) {
-            let path = value.path;
-            let latestWatches = this.watchers.get(path);
-            if (config?.pathsAreSynced && latestWatches && !latestWatches.receivedTime && !path.startsWith(LOCAL_DOMAIN_PATH)) {
-                latestWatches.receivedTime = time;
-                let obj = { start: latestWatches.requestedTime, end: time, path };
-                this.syncHistoryForHarvest.push(obj);
-                this.syncHistoryForDebug.push(obj);
-            }
-
-            function triggerNodeChanged(watcher: NodeId) {
-                let changes = changedPerCallbacks.get(watcher);
-                if (!changes) {
-                    changes = new Set();
-                    changedPerCallbacks.set(watcher, changes);
-                }
-                // @ts-ignore
-                changes.add(value);
-            }
-
-            if (latestWatches) {
-                for (let watch of latestWatches.watchers) {
-                    triggerNodeChanged(watch);
-                }
-            }
-
-            let parentPath = getParentPathStr(path);
-            let latestParentWatches = this.parentWatchers.get(parentPath);
-            if (latestParentWatches) {
-                let pathRoutingHash: number | undefined = undefined;
-                for (let { start, end, watchers } of latestParentWatches.values()) {
-                    if (!matchesParentRangeFilter({
-                        parentPath,
-                        fullPath: path,
-                        start,
-                        end,
-                    })) {
-                        continue;
-                    }
-                    for (let watch of watchers) {
-                        triggerNodeChanged(watch);
-                    }
-                }
-            }
-        }
-        for (let parentPath of config?.parentsSynced ?? []) {
-            let latestParentWatches = this.parentWatchers.get(parentPath);
-            if (latestParentWatches) {
-                for (let { watchers } of latestParentWatches.values()) {
-                    for (let watcher of watchers) {
-                        let changes = changedPerCallbacks.get(watcher);
-                        if (!changes) {
-                            changes = new Set();
-                            changedPerCallbacks.set(watcher, changes);
-                        }
-                    }
-                }
-            }
-        }
-        return changedPerCallbacks;
-    }
-
-    public isWatching(path: string): boolean {
-        return this.watchers.has(path) || this.parentWatchers.has(getParentPathStr(path));
-    }
-
-    @measureFnc
-    private triggerLatestWatcher(
-        watcher: PathWatcherCallback,
-        changes: PathValue[],
-        parentPaths?: string[],
-        initialTrigger?: "initialTrigger"
-    ) {
-        if (isOwnNodeId(watcher)) {
-            for (let callback of this.localTriggerCallbacks) {
-                callback(changes, parentPaths ?? []);
-            }
-        } else {
-            if (!isCoreQuiet) {
-                console.log(`(${Date.now()}) Sending values to client: ${changes.length} (${watcher})`);
-            }
-            this.ensureUnwatchingOnDisconnect(watcher);
-            ignoreErrors((async () => {
-                let allowSource = await isNodeTrusted(watcher) || getNodeIdIP(watcher) === "127.0.0.1";
-                let buffers = await pathValueSerializer.serialize(changes, {
-                    noLocks: true,
-                    compress: getCompressNetwork(),
-                    stripSource: !allowSource,
-                });
-
-                if (isDebugLogEnabled() || isDiskAudit()) {
-                    for (let pathValue of changes) {
-                        auditLog("SEND VALUE", {
-                            path: pathValue.path,
-                            time: pathValue.time.time,
-                            watcher,
-                            nodeId: debugNodeId(watcher),
-                            targetNodeId: debugNodeId(watcher),
-                            targetNodeThreadId: debugNodeThread(watcher),
-                            transparent: pathValue.isTransparent,
-                            canGC: pathValue.canGCValue,
-                        });
-                    }
-                }
-                await PathValueController.nodes[watcher].forwardWrites(
-                    buffers,
-                    parentPaths,
-                    undefined,
-                    initialTrigger,
-                );
-            })());
-        }
-    }
-
-    private ensureUnwatchingOnDisconnect = cache((nodeId: string) => {
-        if (isOwnNodeId(nodeId)) return;
-        SocketFunction.onNextDisconnect(nodeId, async () => {
-            this.ensureUnwatchingOnDisconnect.clear(nodeId);
-
-            // Wait while, so Querysub doesn't thrash when clients connect and disconnect
-            //  TODO: We should be smarter about our wait time, waiting less if we have a lot of resource
-            //      pressure, and more (potentially forever), if we don't have much resource pressure
-            //      (memory, cpu, and network).
-            setTimeout(() => {
-                let watches = this.watchersToPaths.get(nodeId);
-                this.watchersToPaths.delete(nodeId);
-                if (watches) {
-                    this.unwatchPath({ paths: Array.from(watches.paths), parentPaths: Array.from(watches.parents), callback: nodeId });
-                }
-            }, MAX_CHANGE_AGE);
-        });
-    });
-
-    private localTriggerCallbacks = new Set<(changes: PathValue[], parentPaths: string[]) => void>();
-    public watchAllLocalTriggers(callback: (changes: PathValue[], parentPaths: string[]) => void) {
-        this.localTriggerCallbacks.add(callback);
-    }
-
-    public unwatchedCallbacks = new Set<(config: WatchConfig) => void>();
-    public watchUnwatched(callback: (config: WatchConfig) => void) {
-        this.unwatchedCallbacks.add(callback);
-    }
-
-    public getAllParentWatches() {
-        return Array.from(this.parentWatchers.keys());
-    }
-
-    public debug_harvestSyncTimes(): { start: number; end: number; path: string; }[] {
-        let times = this.syncHistoryForHarvest.getAllUnordered();
-        this.syncHistoryForHarvest.reset();
-        return times;
-    }
-
-    public debug_getSyncHistory(): { start: number; end: number; path: string; }[] {
-        return this.syncHistoryForDebug.getAllUnordered();
-    }
-}
-export const pathWatcher = new PathWatcher();
-
-
-class WriteValidStorage {
-    // We could have a more efficient storage for non-range, but... we need range storage anyways,
-    //  so... this is fine.
-    // (Not sorted)
-    //  - May have duplicates for the same path (for lockless writes), always with the same valid state.
-    // path => WriteState[]
-    //  WriteState is UNSORTED (it is only kept around for MAX_CHANGE_AGE, so this should be the fastest way to do it)
-    private validStorage = registerMapArrayResource("validStorage", new Map<string, WriteState[]>());
-
-    private delayedInvalidate = ((lock: ReadLock, targetTime: number, valueGroupForPredictionHack: PathValue[]) => {
-        const tryNow = () => {
-            if (Date.now() >= targetTime) {
-                setTimeout(tryNow, Date.now() - targetTime + 50);
-                return;
-            }
-            pathValueCommitter.ingestValidStates(valueGroupForPredictionHack.map(x => ({
-                path: x.path,
-                isValid: true,
-                time: x.time,
-                isTransparent: x.isTransparent || false,
-            })), undefined, "recomputeValidState");
-        };
-        tryNow();
-    });
-
-    public getWriteState(readLock: ReadLock, now: number): WriteState {
-        let isValid = this.isLockValid(readLock, now);
-        return { path: readLock.path, isValid, time: readLock.startTime, isTransparent: readLock.readIsTransparent };
-    }
-    public isLockValid(readLock: ReadLock, now: number, valueGroupForPredictionHack?: PathValue[]): boolean {
-        let isValid = this.isLockValidBase(readLock, now);
-        if (!isValid && readLock.keepRejectedUntil && now < readLock.keepRejectedUntil && valueGroupForPredictionHack) {
-            isValid = true;
-            // TODO: Test this code. We haven't run it, as it is a bit annoying to set up (we need to predict
-            //  writes to a new location). It will be pretty obvious if it is failing, but... I don't think it will?
-            console.log(yellow(`Delaying rejection of ${readLock.path} to try to fix out of order prediction invalidation`));
-            // Trigger a recheck when the keepRejectedUntil time is reached
-            this.delayedInvalidate(readLock, readLock.keepRejectedUntil, valueGroupForPredictionHack);
-        }
-        return isValid;
-    }
-    public isLockValidBase(readLock: ReadLock, now: number): boolean {
-        // If it old enough it must be valid, otherwise how would a client NOT know it was invalid
-        //  (assuming clients clear their reads aftering being disconnecting for long enough).
-        if (readLock.startTime.time < now - MAX_CHANGE_AGE) {
-            return true;
-        }
-
-        let values = this.validStorage.get(readLock.path);
-        let time = readLock.startTime;
-        if (readLock.readIsTransparent) {
-            // EDIT: Actually... isn't this done so that rejections can cascade from other nodes, with our node
-            //  not even evaluating the actual rejection reason, but just directly using the reject value?
-            // // EDIT: I *think* that the range check should be sufficient for undefined read locks.
-            // //  If that is the case, remove isUndefinedAtLock entirely.
-            // //  - The reason the range check is good enough is that is is checking for values. Actually,
-            // //      if we always checked for values the range check would always be sufficient. HOWEVER,
-            // //      the range + valid check is an optimization, so locks don't need to store their values.
-            // //      But in this case, with the weird stuff we are doing with predictions... and the fact that
-            // //      we already store the value... we simply don't need the check.
-            // return true;
-            return this.isUndefinedAtLock(readLock);
-        }
-        if (!values) {
-            // We have no record of any values on this path, so it must have never been committed!
-            return false;
-        }
-        let value = values.find(x => compareTime(x.time, time) === 0);
-        if (!value) {
-            // If it is golden, it was probably just removed, so assume it was accepted
-            //  (nodes only ask for valid states of values they created, or that were
-            //  just created, so this is fine)
-            if (time.time < now - MAX_CHANGE_AGE) {
-                return true;
-            }
-            return false;
-        }
-        return value.isValid;
-    }
-    private isUndefinedAtLock(lock: ReadLock): boolean {
-        let values = this.validStorage.get(lock.path);
-        let time = lock.startTime;
-        if (values) {
-            // Find the write at read time
-            let latestValue: WriteState | undefined;
-            for (let value of values) {
-                // Skip invalid
-                if (!value.isValid) continue;
-                // Skip writes AFTER our read (but not ON our read, as then we skip our read itself!)
-                if (compareTime(value.time, time) > 0) continue;
-                // Take the newest write that would affect us
-                if (!latestValue || compareTime(value.time, latestValue.time) > 0) {
-                    latestValue = value;
-                }
-            }
-            if (latestValue && !latestValue.isTransparent) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    private getWritesInRange(lock: ReadLock): WriteState[] | undefined {
-        let values = this.validStorage.get(lock.path);
-        if (!values) return undefined;
-        let times: WriteState[] | undefined;
-        for (let value of values) {
-            if (!value.isValid) continue;
-            // NOTE: This is the same comparison as in getValidStateChangedTriggers
-            if (compareTime(lock.startTime, value.time) < 0 && compareTime(value.time, lock.endTime) < 0) {
-                if (!times) times = [];
-                times.push(value);
-            }
-        }
-        return times;
-    }
-
-    // Returns true if the valid state changed
-    public setWriteValidStateValue(pathValue: PathValue): boolean {
-        this.ensureGarbageCollectOldState();
-
-        let time = pathValue.time;
-        // Clone time, so we aren't referencing any of the original object. This is very important for garbage collection.
-        time = { time: time.time, version: time.version, creatorId: time.creatorId, };
-        return this.setWriteValidState({
-            path: pathValue.path,
-            isValid: pathValue.valid || false,
-            time: time,
-            isTransparent: pathValue.isTransparent || false,
-        });
-    }
-    public setWriteValidState(write: WriteState, lockless?: boolean): boolean {
-        if (write.isValid) {
-            auditLog("ACCEPTING VALUE", { path: write.path, time: write.time.time, reason: write.reason });
-        } else {
-            auditLog("REJECTING VALUE", { path: write.path, time: write.time.time, reason: write.reason });
-        }
-        this.ensureGarbageCollectOldState();
-
-        // If lockless then it starts valid, and always stays valid.
-        if (!lockless) {
-            let authorityValue = authorityStorage.getValueExactIgnoreInvalid(write.path, write.time);
-            if (authorityValue) {
-                authorityValue.valid = write.isValid;
-                // NOTE: I think it is fine now for us to set the valid state early? Hopefully...
-                //  because it happens A LOT.
-                // if (!isCoreQuiet) {
-                //     console.log(`Setting valid state of ${debugPathValuePath(authorityValue)} to ${write.isValid}`);
-                // }
-            } else {
-                // if (isNode()) {
-                //     console.error(`Setting valid state of ${write.path}@${debugTime(write.time)} to ${write.isValid}, but the ValuePath was not found. If the ValuePath is found later, it might not have the valid state set correctly.`);
-                // }
-            }
-        }
-
-        let path = write.path;
-        let time = write.time;
-        let isValid = write.isValid;
-        let values = this.validStorage.get(path);
-        if (!values) {
-            values = [];
-            this.validStorage.set(path, values);
-        }
-        // NOTE: We always have to search, even if lockless, so we can return false when the isValid state hasn't changed.
-        // Search from the end, as it is most likely time will have been recently added
-        let index = values.length - 1;
-        while (index >= 0) {
-            let diff = compareTime(values[index].time, time);
-            if (diff === 0) {
-                break;
-            }
-            index--;
-        }
-        if (index >= 0) {
-            if (values[index].isValid === isValid) {
-                return false;
-            }
-            values[index].isValid = isValid;
-            values[index].reason = write.reason;
-        } else {
-            values.push(write);
-        }
-        return true;
-    }
-
-
-    /** SOMEWHAT of a hack. Updates the inputs value states from cache. Needed, as it is possible for valid states
-            to be processed before PathValues. Which would cause the PathValues to have outdated valid states when received.
-            Valid states are always correct, and always updated (if they are sent at all), so we will use the latest valid
-            state instead of latest write state.
-    */
-    @measureFnc
-    public updateValidStatesFromCache(values: PathValue[]) {
-        for (let value of values) {
-            let states = this.validStorage.get(value.path);
-            if (!states) continue;
-            let state = states.find(x => compareTime(x.time, value.time) === 0);
-            if (!state) continue;
-            value.valid = state.isValid;
-        }
-    }
-
-    // NOTE: Mutates the input PathValue.valid states to be the new states
-    // NOTE: Only mutates paths we are an authority on
-    // NOTE: Also sets up watches, so the valid states will update when their readLocks change
-    //  (including talking to remote watchers, etc, etc)
-    @measureFnc
-    public computeValidStates(values: PathValue[], now: number, alreadyWatching?: "alreadyWatching"): WriteState[] {
-        // Calculate valid states
-        //  - For things we are not an authority on, assumes their state is true.
-        //      - If we AREN'T an authority, whomever sent us the values will send us new
-        //          values if these become invalid.
-        //          - Also, if we created the values, we will get sent valid states if
-        //              they become invalid.
-        //          - We don't need to watch locks for pathValues, as any valid states changes
-        //              automatically impact any values that use them (we only need to watch locks
-        //              for values we are computing).
-        //  - For everything we ARE an authority on, computes them
-        //      - Also sets up watches for computed values, so the valid states will stay up to date).
-
-        let changes: WriteState[] = [];
-
-        // If alreadyWatching... then these are triggers caused by a local lock watch. In which case,
-        //  are must want to know if the values changed (as in, for call prediction).
-        if (!alreadyWatching) {
-            measureBlock(function computeValidStates_getSelfValues() {
-                let selfValues: PathValue[] = [];
+    public getAllValues(config: {
+        spec: AuthoritySpec;
+        // Only returns values with a create time in this window
+        startTime: number;
+        endTime: number;
+        // Use pathValueSerializer.deserialize(valueBuffers) on the output buffers
+    }): PathValue[] {
+        let { spec, startTime, endTime } = config;
+        let result: PathValue[] = [];
+        for (let [path, values] of this.values) {
+            if (PathRouter.matchesAuthoritySpec(spec, path)) {
                 for (let value of values) {
-                    if (pathValueAuthority2.isSelfAuthority(value.path)) {
-                        selfValues.push(value);
-                    } else {
-                        let changed = writeValidStorage.setWriteValidStateValue(value);
-                        if (changed) {
-                            changes.push({ path: value.path, isValid: value.valid || false, time: value.time, isTransparent: value.isTransparent || false });
-                        }
-                    }
-                }
-                values = selfValues;
-            });
-        }
-
-        if (values.length === 0) return changes;
-
-        // Watch the value locks, for all SELF VALUES
-        //  (watches remote locks if necessary)
-        if (!alreadyWatching) {
-            lockWatcher.watchValueLocks(values);
-        }
-        let lockGroups = new Map<ReadLock[], PathValue[]>();
-        for (let value of values) {
-            if (value.lockCount === 0) {
-                validateLockCount(value);
-                let change: WriteState = {
-                    path: value.path,
-                    isValid: true,
-                    time: value.time,
-                    isTransparent: value.isTransparent || false
-                };
-                let changed = writeValidStorage.setWriteValidState(change, true);
-                if (changed) {
-                    changes.push(change);
-                }
-                continue;
-            }
-            let lockGroup = lockGroups.get(value.locks);
-            if (!lockGroup) {
-                lockGroup = [];
-                lockGroups.set(value.locks, lockGroup);
-            }
-            lockGroup.push(value);
-        }
-        for (let [locks, valueGroup] of lockGroups) {
-            if (valueGroup.length === 0) continue;
-
-            let rejected = false;
-            for (let lock of locks) {
-                if (!this.isLockValid(lock, now)) {
-                    rejected = true;
-
-                    // This is good... unless it happens A LOT. Then the app needs to change (unless it
-                    //  is a game, or something with realtime competition, in which case this is probably unavoidable).
-                    if ((!isCoreQuiet || !isNode()) && debugRejections || valueGroup.length > 0 && lock.endTime.version !== Number.MAX_SAFE_INTEGER && lock.startTime.version !== -2) {
-                        if (!isNode()) {
-                            debugger;
-                        }
-                        let timeToReject = now - valueGroup[0].time.time;
-                        let message = `!!! VALUE REJECTED DUE TO USING MISSING / REJECTED READ!!!(rejected after ${timeToReject}ms at ${Date.now()})`;
-                        message += `\n${debugTime(valueGroup[0].time)} (write)`;
-                        message += `\n    rejected as the server could not find: `;
-                        if (lock.readIsTransparent) {
-                            message += `\n${debugTime(lock.startTime)} to ${debugTime(lock.endTime)} ${getPathFromStr(lock.path).join(".")} `;
-                        } else {
-                            message += `\n${debugTime(lock.startTime)} ${getPathFromStr(lock.path).join(".")} `;
-                        }
-                        if (lock.readIsTransparent) {
-                            message += `\n    (read was undefined, so presumably a value exists which the writer missed)`;
-                        }
-                        message += `\nFull list of writes rejected: `;
-                        for (let pathValue of valueGroup) {
-                            message += `\n${debugPathValue(pathValue)}`;
-                        }
-                        console.log(red(message));
-
-                        if (debugRejections) {
-                            debugbreak(2);
-                            debugger;
-                            this.isLockValid(lock, now);
-                            debugger;
-                        }
-                    }
-                    break;
-                }
-                let inRange = this.getWritesInRange(lock);
-                if (inRange?.length) {
-                    // If all the offending writes are undefined (or invalid), then we can ignore the contention
-                    if (lock.readIsTransparent && inRange.every(x => x.isTransparent || !x.isValid)) {
-                        continue;
-                    }
-                    rejected = true;
-                    // This is good... unless it happens A LOT. Then the app needs to change (unless it
-                    //  is a game, or something with realtime competition, in which case this is probably unavoidable).
-                    if (
-                        (!isCoreQuiet || !isNode())
-                        // This special version indicates clientside prediction (which SHOULD be rejected).
-                        && lock.endTime.version !== Number.MAX_SAFE_INTEGER
-                        || debugRejections
-                    ) {
-                        let changed = valueGroup.filter(x => x.valid);
-                        if (changed.length > 0) {
-                            let timeToReject = now - changed[0].time.time;
-                            let redMessage = `!!! LOCK CONTENTION FIXED VIA REJECTION OF VALUE!!!(rejected after ${timeToReject}ms)`;
-                            for (let pathValue of changed) {
-                                redMessage += `\n${debugPathValue(pathValue)}`;
-                            }
-                            redMessage += `\n    (write rejected due to original read not noticing value at: ${lock.path})`;
-                            redMessage += `\n    (original read from: ${debugTime(lock.startTime)}`;
-                            redMessage += `\n    (at time: ${debugTime(lock.endTime)}`;
-                            redMessage += `\n    (current time: ${Date.now()})`;
-                            for (let lockFailed of inRange) {
-                                redMessage += `\n    (conflict write at: ${debugTime(lockFailed.time)}`;
-                            }
-                            console.log(red(redMessage));
-                            if (debugRejections) {
-                                debugbreak(2);
-                                debugger;
-                                this.getWritesInRange(lock);
-                                debugger;
-                            }
-                        }
-                    }
-                    break;
-                }
-            }
-            // NOTE: The if statement is equivalent to this one line, we just iterate so we can
-            //  have better debug info, and rejection metrics tracking.
-            //values.forEach(value => value.valid = !rejected);
-            if (rejected) {
-                for (let pathValue of valueGroup) {
-                    pathValue.valid = false;
-                    rejections.value++;
-                }
-            }
-
-            for (let value of valueGroup) {
-                let change: WriteState = {
-                    path: value.path,
-                    isValid: value.valid || false,
-                    time: value.time,
-                    isTransparent: value.isTransparent || false
-                };
-                let changed = writeValidStorage.setWriteValidState(change);
-                if (changed) {
-                    changes.push(change);
-                }
-            }
-        }
-
-        return changes;
-    }
-
-    public deleteRemovedPath(path: string) {
-        this.validStorage.delete(path);
-    }
-
-    private ensureGarbageCollectOldState = lazy(() => runInfinitePoll(MAX_CHANGE_AGE, () => {
-        // Clear all valid states after they are old enough. We will just tell anyone who asks that
-        //  they are valid, because... the must be if someone still cares about them (as either they have been
-        //  syncing for a long time, and so they must have never gotten an invalid message and it is too late
-        //  for that to change now, or... they are new, which means they will either be given old valid values,
-        //  or new values which may be invalid but are too new for us to garbage collect).
-        let garbageCollectTime = Date.now() - MAX_CHANGE_AGE;
-        for (let [key, values] of this.validStorage) {
-            values = values.filter(x => x.time.time > garbageCollectTime);
-            if (values.length === 0) {
-                this.validStorage.delete(key);
-            } else {
-                this.validStorage.set(key, values);
-            }
-        }
-    }));
-}
-export const writeValidStorage = new WriteValidStorage();
-
-let rejections = { value: 0 };
-export function internalGetRejections(): { value: number } {
-    return rejections;
-}
-export function internalTestResetRejections() {
-    rejections.value = 0;
-}
-
-class LockWatcher {
-    @measureFnc
-    public watchValueLocks(values: PathValue[]): void {
-        let { newRemoteLocks } = lockWatchDeduper.localWatchNewLocks({ values: values });
-        if (newRemoteLocks.size > 0) {
-            logErrors(this.watchRemoteLocks(newRemoteLocks));
-        }
-    }
-    private watchRemoteLocks = batchFunction(
-        { delay: "afterio" },
-        async (locksBatched: Set<ReadLock>[]) => {
-            let locks = new Set(locksBatched.flatMap(x => Array.from(x)));
-            let locksByAuthority = new Map<string, Set<ReadLock>>();
-            for (let lock of locks) {
-                if (pathValueAuthority2.isSelfAuthority(lock.path)) continue;
-
-                let authorityId = await pathValueAuthority2.getSingleReadNodePromise(lock.path);
-                // If they don't trust us, we just have to assume the value we read is correct.
-                if (!await isTrustedByNode(authorityId)) continue;
-                let locks = locksByAuthority.get(authorityId);
-                if (!locks) {
-                    locks = new Set();
-                    locksByAuthority.set(authorityId, locks);
-                }
-                locks.add(lock);
-            }
-
-            for (let [authorityId, locks] of locksByAuthority) {
-                this.watchLocksOnAuthority(authorityId, locks);
-            }
-        }
-    );
-    private watchLocksOnAuthority(authorityId: string, locks: Set<ReadLock>) {
-        if (!Array.from(locks).some(x => lockWatchDeduper.isLockStillWatched(x))) return;
-
-        let alreadyReconnected = false;
-        const reconnectWatches = () => {
-            if (alreadyReconnected) return;
-            alreadyReconnected = true;
-            if (!Array.from(locks).some(x => lockWatchDeduper.isLockStillWatched(x))) return;
-            logErrors(this.watchRemoteLocks(locks));
-        };
-        this.onNextDisconnectList(authorityId).add(reconnectWatches);
-        setTimeout(() => {
-            this.onNextDisconnectList(authorityId).delete(reconnectWatches);
-        }, MAX_CHANGE_AGE * 2);
-
-        let connection = PathValueController.nodes[authorityId].watchLockValid(
-            Array.from(locks.values())
-        );
-        logErrors(connection);
-        connection.catch(() => reconnectWatches());
-    }
-
-    private onNextDisconnectList = cache((nodeId: string) => {
-        let callbacks = new Set<() => void>();
-        SocketFunction.onNextDisconnect(nodeId, () => {
-            this.onNextDisconnectList.clear(nodeId);
-            for (let callback of callbacks) {
-                callback();
-            }
-        });
-        return callbacks;
-    });
-}
-export const lockWatcher = new LockWatcher();
-
-class LockToCallbackLookup {
-    // time.creatorId => time => callbacks
-    private validWatchers = registerResource("paths|validWatchers", new Map<number, Map<number, Set<WriteCallback>>>());
-
-    // path => sorted by endTime
-    private validRangeWatchers = registerResource("paths|validRangeWatchers", new Map<string, {
-        startTime: Time;
-        endTime: Time;
-        // Called back if there is a valid value between startTime (exclusive) and endTime (exclusive)
-        callback: WriteCallback;
-    }[]>());
-
-    /** Watchs both the startTime, and the range */
-    public watchLock(lock: ReadLock, callback: WriteCallback) {
-        this.ensureGarbageCollectLoop();
-        // Add valid watcher
-        if (lock.endTime.time > 0) {
-            const time = lock.startTime;
-            let maps = this.validWatchers.get(time.creatorId);
-            if (!maps) {
-                maps = new Map();
-                this.validWatchers.set(time.creatorId, maps);
-            }
-            let callbacksList = maps.get(time.time);
-            if (!callbacksList) {
-                callbacksList = new Set();
-                maps.set(time.time, callbacksList);
-            }
-            callbacksList.add(callback);
-        }
-        // Add valid range watcher
-        if (compareTime(lock.startTime, lock.endTime) !== 0) {
-            let { path, startTime, endTime } = lock;
-            let watchers = this.validRangeWatchers.get(path);
-            if (!watchers) {
-                watchers = [];
-                this.validRangeWatchers.set(path, watchers);
-            }
-            // Find the index to insert into, maintaining a sort by time
-            let index = -1;
-            for (let i = watchers.length - 1; i >= 0; i--) {
-                if (watchers[i].endTime.time < endTime.time) {
-                    index = i + 1;
-                    break;
-                }
-            }
-            if (index === -1) {
-                index = watchers.length;
-            }
-            watchers.splice(index, 0, { startTime, endTime, callback });
-        }
-    }
-
-    public garbageCollectOldWatchers() {
-        const disposeTime = Date.now() - MAX_CHANGE_AGE * 2;
-
-        for (let [path, times] of this.validRangeWatchers) {
-            let expiredIndex = times.findIndex(x => x.endTime.time < disposeTime);
-            if (expiredIndex >= 0) {
-                times.splice(expiredIndex, times.length - expiredIndex);
-            }
-        }
-
-        for (let [key, maps] of this.validWatchers) {
-            for (let time of maps.keys()) {
-                if (time < disposeTime) {
-                    maps.delete(time);
-                    if (maps.size === 0) {
-                        this.validWatchers.delete(key);
+                    let time = value.time.time;
+                    if (startTime <= time && time <= endTime) {
+                        result.push(value);
                     }
                 }
             }
         }
-
-        for (let [path, watchers] of this.validRangeWatchers) {
-            for (let i = watchers.length - 1; i >= 0; i--) {
-                let watcher = watchers[i];
-                if (watcher.endTime.time < disposeTime) {
-                    watchers.splice(i, 1);
-                }
-            }
-            if (watchers.length === 0) {
-                this.validRangeWatchers.delete(path);
-            }
-        }
+        return result;
     }
-
-    public getValidStateChangedTriggers(
-        remoteValue: WriteState
-    ): WriteCallback[] {
-        let allCallbacks: WriteCallback[] = [];
-        let validMaps = this.validWatchers.get(remoteValue.time.creatorId);
-        if (validMaps) {
-            let callbacks = validMaps.get(remoteValue.time.time);
-            if (callbacks) {
-                for (let callbackList of callbacks) {
-                    allCallbacks.push(callbackList);
-                }
-            }
-        }
-        let rangeWatchers = this.validRangeWatchers.get(remoteValue.path);
-        if (rangeWatchers) {
-            for (let watcher of rangeWatchers) {
-                if (
-                    // NOTE: This is the same comparison as in getWritesInRange
-                    // If the time is > startTime (exclusive, as startTime MUST exist, as we depend on it)
-                    compareTime(watcher.startTime, remoteValue.time) < 0
-                    // And < endTime (exclusive, as endTime is assumed to exist, as it is probably when we are writing!)
-                    && compareTime(remoteValue.time, watcher.endTime) < 0
-                ) {
-                    allCallbacks.push(watcher.callback);
-                }
-            }
-        }
-        return allCallbacks;
-    }
-
-    private ensureGarbageCollectLoop = lazy(() => {
-        runInfinitePoll(MAX_CHANGE_AGE, () => lockToCallback.garbageCollectOldWatchers());
-    });
-
-
 }
-export const lockToCallback = new LockToCallbackLookup();
-
-// NOTE: We assume there will be no equivalent but !== PathValues. We also assume
-//  there will be no equivalent but !== Locks. Fair assumptions, which save so
-//  much time it is probably worth maintaining them. AND, if they are invalidated,
-//  the only penalty is a memory leak, which isn't so bad (arguably having identical
-//  values with difference instances is a memory leak too).
-class LockWatchDeduper {
-    private watchedRemoteLocks = registerResource("paths|watchedRemoteLocks", new Map<ReadLock[], Set<PathValue>>());
-    private watchedLockFlat = registerResource("paths|watchedLockFlat", new Set<ReadLock>());
-
-    /** Calls validWatcher with any new readLocks, using the values as the callback.
-     *      SHOULD ONLY BE USED IF YOU ARE WATCHING THE LOCKS, aka, if you are
-     *          the authority on the values. Otherwise, you are NOT watching readLocks,
-     *          you are watching the valid state, via the actual authority of the paths.
-     */
-    public localWatchNewLocks(config: { values: PathValue[]; }): {
-        newRemoteLocks: Set<ReadLock>;
-    } {
-        this.ensureLockCleanupLoop();
-
-        let byLock = new Map<ReadLock[], PathValue[]>();
-        for (let value of config.values) {
-            validateLockCount(value);
-            if (value.lockCount === 0) continue;
-            let values = byLock.get(value.locks);
-            if (!values) {
-                values = [];
-                byLock.set(value.locks, values);
-            }
-            values.push(value);
-        }
-
-        let newLocks: ReadLock[] = [];
-        for (let value of config.values) {
-            validateLockCount(value);
-            if (value.lockCount === 0) continue;
-            let values = this.watchedRemoteLocks.get(value.locks);
-            if (!values) {
-                values = new Set();
-                this.watchedRemoteLocks.set(value.locks, values);
-                newLocks.push(...value.locks);
-            }
-            values.add(value);
-        }
-        for (let locks of byLock.keys()) {
-            for (let lock of locks) {
-                this.watchedLockFlat.add(lock);
-            }
-        }
-        let newRemoteLocks = new Set<ReadLock>();
-
-        for (let [locks, values] of byLock) {
-            for (let lock of locks) {
-                // NOTE: We watch LOCAL_DOMAIN paths, as they might depend on a remote value, which is invalidated.
-                //  This can happen for routing, where you click something like "go to main node", before
-                //  the remote node list is loaded. You will go to the wrong page, BUT, once the remote node list
-                //  is loaded, it should reject (and then, ideally we rerun the function clientside on detection
-                //  of the rejection).
-
-                if (!pathValueAuthority2.isSelfAuthority(lock.path)) {
-                    newRemoteLocks.add(lock);
-                }
-                // NOTE: I BELIEVE this is valid, even if we don't own the locks. We might have some
-                //  unnecessary cascading, but... if we depended on a value we will have it, and
-                //  if we are missing any range lock conflicts we will know about them due to
-                //  the remote locks. AND, any values we have are synced, so we don't need to worry about
-                //  any range lock conflicts themselves being rejected, missing that rejection, and so
-                //  incorrectly invalidating valid values that we just received.
-                lockToCallback.watchLock(lock, values);
-            }
-        }
-
-        return { newRemoteLocks };
-    }
-
-    private ensureLockCleanupLoop = lazy(() => {
-        runInfinitePoll(MAX_CHANGE_AGE, () => this.cleanupDeadLocks());
-    });
+export const authorityStorage = new AuthorityPathValueStorage();
+export const values = authorityStorage;
+export const pathValues = authorityStorage;
 
-    @measureFnc
-    private cleanupDeadLocks() {
-        let deadTime = Date.now() - MAX_CHANGE_AGE;
-        for (let [locks, values] of this.watchedRemoteLocks) {
-            let isDead = true;
-            for (let value of values) {
-                if (value.time.time > deadTime) {
-                    isDead = false;
-                    break;
-                }
-            }
-            if (isDead) {
-                for (let lock of locks) {
-                    this.watchedLockFlat.delete(lock);
-                }
-                this.watchedRemoteLocks.delete(locks);
-            }
-        }
-    }
 
-    public isLockStillWatched(lock: ReadLock): boolean {
-        return this.watchedLockFlat.has(lock);
-    }
-}
-export const lockWatchDeduper = new LockWatchDeduper();
 
 // Async import, as we are not allowed synchronous imports of values in
 //  higher tiers than us. We can't expose a callback, as nothing else
 //  can trigger the import of memoryValueAudit for all clients as consistently
 //  as the core.
 setImmediate(() => {
-    //logErrors(import("../5-diagnostics/memoryValueAudit").then(x => x.startMemoryAuditLoop()));
-    //logErrors(import("../5-diagnostics/diskValueAudit").then(x => x.startDiskAuditLoop()));
     logErrors(import("../5-diagnostics/synchronousLagTracking").then(x => x.trackSynchronousLag()));
 });