querysub 0.406.0 → 0.408.0

package/src/1-path-client/RemoteWatcher.ts

@@ -2,24 +2,26 @@
 import { SocketFunction } from "socket-function/SocketFunction";
 import { batchFunction, runInSerial, runInfinitePoll } from "socket-function/src/batching";
 import { cache } from "socket-function/src/caching";
-import { isNode } from "socket-function/src/misc";
+import { isNode, sort } from "socket-function/src/misc";
 import { measureFnc, measureBlock } from "socket-function/src/profiling/measure";
 import { isOwnNodeId } from "../-f-node-discovery/NodeDiscovery";
 import { PathValueController } from "../0-path-value-core/PathValueController";
-import { PathRouter } from "../0-path-value-core/PathRouter";
+import { AuthoritySpec, PathRouter } from "../0-path-value-core/PathRouter";
 import { WatchConfig, authorityStorage } from "../0-path-value-core/pathValueCore";
 import { pathWatcher } from "../0-path-value-core/PathWatcher";
 import { ActionsHistory } from "../diagnostics/ActionsHistory";
 import { registerResource } from "../diagnostics/trackResources";
 import { logErrors } from "../errors";
-import { green, yellow } from "socket-function/src/formatting/logColors";
-import { getParentPathStr } from "../path";
+import { blue, green, yellow } from "socket-function/src/formatting/logColors";
+import { getParentPathStr, hack_stripPackedPath } from "../path";
 import { isEmpty } from "../misc";
 import { isDevDebugbreak } from "../config";
 import { auditLog, isDebugLogEnabled } from "../0-path-value-core/auditLogs";
 import { debugNodeThread } from "../-c-identity/IdentityController";
 import { authorityLookup } from "../0-path-value-core/AuthorityLookup";
-import { decodeParentFilter, encodeParentFilter } from "../0-path-value-core/hackedPackedPathParentFiltering";
+import { decodeParentFilter, encodeParentFilter, registerGetSpecForChildPath } from "../0-path-value-core/hackedPackedPathParentFiltering";
+import { removeRange, rangesOverlap } from "../rangeMath";
+
 setImmediate(() => import("../4-querysub/Querysub"));
 
 // NOTE: In some cases this can half our the PathValues sent. AND, it can reduce our sync requests by N, and as those are uploads those are event more expensive. However, it also complicates other code, requiring not just checking if a value is synced, but also the parent path. We should try to make this stable, but worst case scenario, we can set this to false, and it will make our synchronization a lot easier to verify.
@@ -35,19 +37,25 @@ export class RemoteWatcher {
     // path => nodeId
     //  isOwnNodeId(nodeId) means we are watching it locally
     private remoteWatchPaths = registerResource("paths|remoteWatchPaths", new Map<string, string>());
-    // inputPath => 
-    private remoteWatchParents = registerResource("paths|remoteWatchParents", new Map<string, {
-        useFullPathHash: boolean;
-        // Might vary from the input path if useFullPathHash is true (and the path is a hacked path, and so which has a range restriction).
-        watchedPath: string;
-        nodesId: Map<string, {
+
+    // cleanPath (hack_stripPackedPath(path)) =>
+    private remoteWatchParents2 = registerResource("paths|remoteWatchParents", new Map<string, {
+        ranges: {
+            // inclusive
             start: number;
+            // exclusive
             end: number;
-        }>;
-        // Watches which we suppressed, due to this parent sync. If this parent sync stops,
-        //  we will need to re-send the watches.
-        suppressedWatches: Set<string>;
-        fullNodeCount: number;
+            // encodeParentFilter({ path: cleanPath, startFraction: start, endFraction: end })
+            finalPath: string;
+            // All of the requests paths that request it (pre decodeParentFilter).
+            inputPaths: Set<string>;
+
+            // The authorityId satisifying this request
+            authorityId: string;
+            authoritySpec: AuthoritySpec;
+
+            suppressedWatches: Set<string>;
+        }[];
     }>());
 
     private disconnectedPaths = registerResource("paths|disconnectedPaths", new Set<string>());
@@ -69,22 +77,27 @@ export class RemoteWatcher {
                     }
                 }
                 let parentPaths: string[] = [];
-                for (let [path, watchObj] of this.remoteWatchParents.entries()) {
-                    if (typeof watchObj.nodesId === "string") {
-                        if (watchObj.nodesId === authorityId) {
-                            this.remoteWatchParents.delete(path);
-                            parentPaths.push(path);
+
+                // Remove all ranges from remoteWatchParents2 that matches this, adding all inputPaths to parentPaths so we can try to rewatch them again
+                for (let [cleanPath, watchObj] of this.remoteWatchParents2.entries()) {
+                    let removedRanges = watchObj.ranges.filter(x => x.authorityId === authorityId);
+                    watchObj.ranges = watchObj.ranges.filter(x => x.authorityId !== authorityId);
+                    if (watchObj.ranges.length === 0) {
+                        this.remoteWatchParents2.delete(cleanPath);
+                    }
+                    for (let range of removedRanges) {
+                        for (let inputPath of range.inputPaths) {
+                            parentPaths.push(inputPath);
                         }
-                    } else {
-                        if (watchObj.nodesId.has(authorityId)) {
-                            watchObj.nodesId.delete(authorityId);
-                            if (isEmpty(watchObj.nodesId)) {
-                                this.remoteWatchParents.delete(path);
-                            }
-                            parentPaths.push(path);
+                        for (let suppressedPath of range.suppressedWatches) {
+                            if (!this.remoteWatchPaths.has(suppressedPath)) continue;
+                            // NOTE: We shouldn't need to remove the remote watch path, as it being suppressed means it shouldn't be watched. However, I guess we can because we definitely don't want to double-watch it.
+                            this.remoteWatchPaths.delete(suppressedPath);
+                            paths.push(suppressedPath);
                         }
                     }
                 }
+
                 if (paths.length === 0 && parentPaths.length === 0) return;
 
                 for (let path of paths) {
@@ -120,14 +133,23 @@ export class RemoteWatcher {
     }
 
 
+    public getRemoteWatchParentRange(path: string) {
+        let parentPath = getParentPathStr(path);
+        let watchObj = this.remoteWatchParents2.get(parentPath);
+        if (!watchObj) return undefined;
+        // NOTE: PathRouter.getChildReadNodes PROMISES That all of the nodes will hash in the same way, and if they all hash in the same way, and they have different ranges, then every path will uniquely map to a single value. 
+        return watchObj.ranges.find(x => {
+            let route = PathRouter.getRouteFull({ path, spec: x.authoritySpec });
+            return x.start <= route && route < x.end;
+        });
+    }
+
+
     public debugIsWatchingPath(path: string) {
         // HACK: If there is no read node... pretend we are watching it. Because... for now, this is a known
         //  and the code calling this function isn't looking for that specific issue.
         return this.remoteWatchPaths.has(path) || !PathRouter.getReadyAuthority(path);
     }
-    public debugIsWatchingParentPath(path: string) {
-        return this.remoteWatchParents.has(path) || !PathRouter.getReadyAuthority(path);
-    }
 
     /** @deprecated If you want to watch something, call pathWatcher.watchPath instead. */
     public watchLatest(config: WatchConfig & { debugName?: string }) {
@@ -149,10 +171,16 @@ export class RemoteWatcher {
         return this.watchLatestBase(config);
     }
 
-    /** Returns [] if we aren't remotely syncing the path. */
-    public getMultiNodesForParent(path: string): Map<string, unknown> | undefined {
-        let watchObj = this.remoteWatchParents.get(path);
-        return watchObj?.nodesId;
+    // As in, is this the path that we're actually watching on the remote? We remap all of the requested paths to the final paths. So, this won't be something that the client application code would understand. However, this would be what the remote server thinks we're intending to watch. 
+    public isFinalRemoteWatchPath(config: {
+        parentPath: string;
+        nodeId: string;
+    }) {
+        let { parentPath, nodeId } = config;
+        let cleanPath = hack_stripPackedPath(parentPath);
+        let watchObj = this.remoteWatchParents2.get(cleanPath);
+        if (!watchObj) return false;
+        return watchObj.ranges.some(x => x.authorityId === nodeId && x.finalPath === parentPath);
     }
 
     private watchUnwatchSerial = runInSerial(async (name: string, fnc: () => Promise<unknown>) => {
@@ -176,7 +204,6 @@ export class RemoteWatcher {
         forceWatch?: boolean;
     }) {
         let watchesPerAuthority = new Map<string, { paths: string[]; parentPaths: string[] }>();
-
         let unwatchParentsPerAuthority = new Map<string, Set<string>>();
 
         let newDisconnectPaths = 0;
@@ -236,128 +263,113 @@ export class RemoteWatcher {
                 paths.paths.push(path);
             }
 
-            for (let originalPath of config.parentPaths) {
+            for (let path of config.parentPaths) {
                 // NOTE: We weren't ignoring local paths here for a while, but... I'm pretty sure we should, to save time.
-                if (PathRouter.isLocalPath(originalPath)) continue;
-                let watchObj = this.remoteWatchParents.get(originalPath);
-                if (
-                    watchObj
-                    && watchObj.nodesId.size === watchObj.fullNodeCount
-                    && !config.tryReconnect
-                ) continue;
-
-                let { useFullPathHash, nodes } = PathRouter.getChildReadNodes(originalPath, {
-                    // Pass existing connected node ids as preferred
-                    preferredNodeIds: watchObj && Array.from(watchObj.nodesId.keys())
-                });
-                let watchedPath = originalPath;
-                useFullPathHash = !!useFullPathHash;
-                let decodedParentFilter = decodeParentFilter(originalPath);
-                if (useFullPathHash && decodedParentFilter) {
-                    watchedPath = encodeParentFilter({
-                        path: decodedParentFilter.path,
-                        startFraction: decodedParentFilter.start,
-                        endFraction: decodedParentFilter.end,
-                        useFullPathHash: true,
-                    });
-                }
+                if (PathRouter.isLocalPath(path)) continue;
 
-                // Unwatch the old watchedPath
-                if (watchObj && watchObj.watchedPath !== watchedPath) {
-                    for (let nodeId of watchObj.nodesId.keys()) {
-                        let parentPaths = unwatchParentsPerAuthority.get(nodeId);
-                        if (!parentPaths) {
-                            parentPaths = new Set();
-                            unwatchParentsPerAuthority.set(nodeId, parentPaths);
-                        }
-                        parentPaths.add(watchObj.watchedPath);
-                    }
+                // IMPORTANT! We HAVE to watch only the range we want, as... if we happen to watch more than the node has, it'll try to get it from other nodes, which is definitely not what we want. 
 
-                    watchObj = undefined;
-                }
+                let decodedParentFilter = decodeParentFilter(path);
+                let cleanPath = decodedParentFilter?.path ?? path;
 
                 let rangeStart = 0;
                 let rangeEnd = 1;
-
-                let nodesToAdd = new Map<string, { start: number; end: number }>();
                 if (decodedParentFilter) {
                     rangeStart = decodedParentFilter.start;
                     rangeEnd = decodedParentFilter.end;
                 }
 
-                {
-                    let curStart = 0;
-                    for (let node of nodes) {
-                        let r = node.range;
-                        if (r.start > curStart) {
-                            console.warn(`There is a gap in the range of nodes for path ${originalPath} values from from ${curStart} to ${r.start} cannot be found in any nodes.`);
-                            curStart = r.start;
-                        }
-                        let nextEnd = Math.min(r.end, rangeEnd);
-                        // Ignore values with no overlap (mostly trailing values)
-                        if (nextEnd <= curStart) continue;
+                let watchObj = this.remoteWatchParents2.get(cleanPath);
 
-                        nodesToAdd.set(node.nodeId, { start: curStart, end: nextEnd });
-                        curStart = nextEnd;
+                if (watchObj && !config.tryReconnect) {
+                    // If all the ranges we want are already covered, then we can just use them
+                    let requiredRanges: { start: number; end: number }[] = [{
+                        start: rangeStart,
+                        end: rangeEnd,
+                    }];
+                    for (let range of watchObj.ranges) {
+                        removeRange(requiredRanges, range);
                     }
-                }
-
-                let fullRangeCovered = true;
-                {
-                    let lastValue = rangeStart;
-                    for (let node of nodes) {
-                        if (node.range.start > lastValue) {
-                            fullRangeCovered = false;
-                            break;
+                    if (requiredRanges.length === 0) {
+                        this.disconnectedParents.delete(path);
+                        for (let range of watchObj.ranges) {
+                            if (rangesOverlap(range, { start: rangeStart, end: rangeEnd })) {
+                                range.inputPaths.add(path);
+                            }
                         }
-                        lastValue = node.range.end;
-                    }
-                    if (lastValue < rangeEnd) {
-                        fullRangeCovered = false;
+                        continue;
                     }
                 }
-                if (!fullRangeCovered) {
-                    if (!this.disconnectedParents.has(originalPath)) {
+
+                let { nodes } = PathRouter.getChildReadNodes(cleanPath, {
+                    // Pass existing connected node ids as preferred
+                    preferredNodeIds: watchObj?.ranges.map(x => x.authorityId) || []
+                });
+                // NOTE: getChildReadNodes either returns a full range, or nothing
+                if (nodes.length === 0) {
+                    if (!this.disconnectedParents.has(path)) {
                         newDisconnectParents++;
-                        this.disconnectedParents.add(originalPath);
+                        this.disconnectedParents.add(path);
                     }
-                } else {
-                    this.disconnectedParents.delete(originalPath);
-                    foundParentPaths++;
+                    continue;
                 }
+                this.disconnectedParents.delete(path);
+                foundParentPaths++;
+
+
+                // NOTE: If the previous call to get childrenodes returns something entirely different, that's fine. If there's a disconnect, we would have removed the ranges already, so they're probably still valid. And we passed them as preferred node IDs, so they'll probably be chosen again. But if they weren't, it's fine. We can just add new ranges for any that we happen to be missing.
+                //  - As in, we don't need to find the difference between the previous time, we just need to find what new watches do we need to add.
 
-                // Unwatch nodes that have changed
-                if (watchObj) {
-                    for (let nodeId of watchObj.nodesId.keys()) {
-                        if (!nodesToAdd.has(nodeId)) {
-                            let parentPaths = unwatchParentsPerAuthority.get(nodeId);
-                            if (!parentPaths) {
-                                parentPaths = new Set();
-                                unwatchParentsPerAuthority.set(nodeId, parentPaths);
-                            }
-                            parentPaths.add(watchedPath);
-                            watchObj.nodesId.delete(nodeId);
-                        }
-                    }
-                }
 
                 if (!watchObj) {
-                    watchObj = { nodesId: new Map(), fullNodeCount: 0, suppressedWatches: new Set(), watchedPath, useFullPathHash };
-                    this.remoteWatchParents.set(watchedPath, watchObj);
+                    watchObj = { ranges: [] };
+                    this.remoteWatchParents2.set(cleanPath, watchObj);
                 }
-                watchObj.fullNodeCount = nodes.length;
-                for (let [nodeId, range] of nodesToAdd) {
-                    watchObj.nodesId.set(nodeId, range);
+
+                // Compute which parts of [rangeStart, rangeEnd] aren't yet covered by existing watches
+                let missingRanges: { start: number; end: number }[] = [{ start: rangeStart, end: rangeEnd }];
+                for (let range of watchObj.ranges) {
+                    removeRange(missingRanges, range);
                 }
 
-                // NOTE: We watch every node with the full request. If our nodes are sharded well, this should be fine. They won't have that much data to give us, and we'll ignore it when we receive it if it's more than we want. 
-                for (let authorityId of nodesToAdd.keys()) {
-                    let paths = watchesPerAuthority.get(authorityId);
-                    if (!paths) {
-                        paths = { paths: [], parentPaths: [] };
-                        watchesPerAuthority.set(authorityId, paths);
+                // For each missing sub-range, clip each node's range to exactly that sub-range and add it.
+                // NOTE: Nodes has no internal overlaps, and missing ranges by definition are only values that we haven't added (and itself has no overlaps). And so adding the intersection of those will also have no overlaps and only add values that we haven't added.
+                for (let missing of missingRanges) {
+                    for (let node of nodes) {
+                        if (!rangesOverlap(node.range, missing)) continue;
+
+                        let clippedStart = Math.max(node.range.start, missing.start);
+                        let clippedEnd = Math.min(node.range.end, missing.end);
+
+                        let finalPath = encodeParentFilter({ path: cleanPath, startFraction: clippedStart, endFraction: clippedEnd });
+                        let existingRange = watchObj.ranges.find(x => x.finalPath === finalPath && x.authorityId === node.nodeId);
+                        if (!existingRange) {
+                            existingRange = {
+                                start: clippedStart,
+                                end: clippedEnd,
+                                finalPath,
+                                inputPaths: new Set(),
+                                authorityId: node.nodeId,
+                                suppressedWatches: new Set(),
+                                authoritySpec: node.authoritySpec,
+                            };
+                            watchObj.ranges.push(existingRange);
+                            let watchesPer = watchesPerAuthority.get(node.nodeId);
+                            if (!watchesPer) {
+                                watchesPer = { paths: [], parentPaths: [] };
+                                watchesPerAuthority.set(node.nodeId, watchesPer);
+                            }
+                            watchesPer.parentPaths.push(finalPath);
+                        }
+                        existingRange.inputPaths.add(path);
+                    }
+                }
+
+                // Register path on pre-existing ranges that already cover parts of [rangeStart, rangeEnd]
+                for (let range of watchObj.ranges) {
+                    if (rangesOverlap(range, { start: rangeStart, end: rangeEnd })) {
+                        range.inputPaths.add(path);
                     }
-                    paths.parentPaths.push(watchedPath);
                 }
             }
         }, `watchLatest|getSingleReadNode`);
@@ -395,13 +407,15 @@ export class RemoteWatcher {
             }
 
             if (STOP_KEYS_DOUBLE_SENDS) {
+                // NOTE: We could already be watching the value watches, in which case watching the parent watches will cause us to double watch them. This is fine. We don't need to remove all double watches. We just want to remove some. 
                 paths = paths.filter(path => {
-                    let parentPath = getParentPathStr(path);
-                    let parentObj = this.remoteWatchParents.get(parentPath);
-                    if (!parentObj) return true;
-                    parentObj.suppressedWatches.add(path);
-                    auditLog("remoteWatcher outer WATCH SUPPRESSED", { path, remoteNodeId: authorityId });
-                    return false;
+                    let range = this.getRemoteWatchParentRange(path);
+                    if (range) {
+                        range.suppressedWatches.add(path);
+                        auditLog("remoteWatcher outer WATCH SUPPRESSED", { path, remoteNodeId: authorityId });
+                        return false;
+                    }
+                    return true;
                 });
             }
 
@@ -428,6 +442,7 @@ export class RemoteWatcher {
             const { Querysub } = await import("../4-querysub/Querysub");
             await this.watchUnwatchSerial("watchLatestRemote", async () => {
                 let byAuthority = new Map<string, { paths: Set<string>; parentPaths: Set<string>; }>();
+                // Collect them and also verify that we're still watching the same authority as we were when we started the batched call
                 for (let { authorityId, paths, parentPaths } of batched) {
                     let pathsPerAuthority = byAuthority.get(authorityId);
                     if (!pathsPerAuthority) {
@@ -440,9 +455,10 @@ export class RemoteWatcher {
                         pathsPerAuthority.paths.add(path);
                     }
                     for (let path of parentPaths) {
-                        let watchObj = this.remoteWatchParents.get(path);
+                        let cleanPath = hack_stripPackedPath(path);
+                        let watchObj = this.remoteWatchParents2.get(cleanPath);
                         if (!watchObj) continue;
-                        if (!watchObj.nodesId.has(authorityId)) continue;
+                        if (!watchObj.ranges.some(x => x.finalPath === path && x.authorityId === authorityId)) continue;
                         pathsPerAuthority.parentPaths.add(path);
                     }
                 }
@@ -470,6 +486,7 @@ export class RemoteWatcher {
                             auditLog("Asking to watch parent path", { path, authorityId, targetNodeThreadId: debugNodeThread(authorityId) });
                         }
                     }
+
                     logErrors(RemoteWatcher.REMOTE_WATCH_FUNCTION(config, authorityId));
                 }
             });
@@ -525,19 +542,27 @@ export class RemoteWatcher {
         }
         let suppressedRewatches = new Set<string>();
         for (let path of config.parentPaths) {
-            let watchObj = this.remoteWatchParents.get(path);
+            let cleanPath = hack_stripPackedPath(path);
+            let watchObj = this.remoteWatchParents2.get(cleanPath);
             if (!watchObj) continue;
-            // Rewatch anything that we suppressed watching (which happens when STOP_KEYS_DOUBLE_SENDS is set)
-            for (let suppressedWatch of watchObj.suppressedWatches) {
-                // Only if we are still watching it (which most of the time, we won't be)
-                if (!this.remoteWatchPaths.has(suppressedWatch)) continue;
-                suppressedRewatches.add(suppressedWatch);
-                auditLog("remoteWatcher inner SUPPRESSED rewatched", { path: suppressedWatch });
+            for (let range of watchObj.ranges) {
+                range.inputPaths.delete(path);
+            }
+            let removedRanges = watchObj.ranges.filter(x => x.inputPaths.size === 0);
+            watchObj.ranges = watchObj.ranges.filter(x => x.inputPaths.size > 0);
+            if (watchObj.ranges.length === 0) {
+                this.remoteWatchParents2.delete(cleanPath);
             }
-            for (let authorityId of watchObj.nodesId.keys()) {
-                innerParentPathRemove(path, authorityId);
+            for (let removedRange of removedRanges) {
+                innerParentPathRemove(removedRange.finalPath, removedRange.authorityId);
+                // Rewatch anything that we suppressed watching (which happens when STOP_KEYS_DOUBLE_SENDS is set)
+                for (let suppressedWatch of removedRange.suppressedWatches) {
+                    // Only if we are still watching it (which most of the time, we won't be)
+                    if (!this.remoteWatchPaths.has(suppressedWatch)) continue;
+                    suppressedRewatches.add(suppressedWatch);
+                    auditLog("remoteWatcher inner SUPPRESSED rewatched", { path: suppressedWatch });
+                }
             }
-            this.remoteWatchParents.delete(path);
         }
         if (suppressedRewatches.size > 0) {
             this.internalWatchLatest({
@@ -570,29 +595,22 @@ export class RemoteWatcher {
         this.unwatchLatest(config);
     }
 
+    public async flushWatchers() {
+        await this.watchUnwatchSerial("flushWatchers", async () => { });
+    }
+
     @measureFnc
     public getExistingWatchRemoteNodeId(path: string): string | undefined {
-        let parentPath = getParentPathStr(path);
-        let parentWatchObj = this.remoteWatchParents.get(parentPath);
-        if (parentWatchObj) {
-            for (let [nodeId, obj] of parentWatchObj.nodesId) {
-                if (parentWatchObj.useFullPathHash) {
-                    let route = PathRouter.getSingleKeyRoute(path);
-                    if (obj.start <= route && route < obj.end) {
-                        return nodeId;
-                    }
-                } else {
-                    let route = PathRouter.getRouteChildKey(path);
-                    if (obj.start <= route && route < obj.end) {
-                        return nodeId;
-                    }
-                }
-            }
-            // NOTE: I think it is a bug if we hit here. There shouldn't be a parent, but have us not match it?
-            //  But... I also don't see the harm in checking remoteWatchPaths?
+        let parentRange = this.getRemoteWatchParentRange(path);
+        if (parentRange) {
+            return parentRange.authorityId;
         }
         return this.remoteWatchPaths.get(path);
     }
+    public getValueWatchRemoteNodeId(path: string): string | undefined {
+        return this.remoteWatchPaths.get(path);
+    }
+
     public getAllRemoteWatchedNodeIds() {
         return Array.from(new Set(this.remoteWatchPaths.values()));
     }
@@ -611,7 +629,6 @@ export class RemoteWatcher {
             //      cases where an authority is in a broken state.
 
             let pathsToWatch = new Set<string>();
-            let parentPathsToWatch = new Set<string>();
             for (let [path, nodeId] of this.remoteWatchPaths) {
                 if (nodeId === authorityNodeId) {
                     pathsToWatch.add(path);
@@ -621,19 +638,30 @@ export class RemoteWatcher {
             for (let path of pathsToWatch) {
                 this.remoteWatchPaths.delete(path);
             }
-            for (let [path, watchObj] of this.remoteWatchParents) {
-                if (watchObj.nodesId.has(authorityNodeId)) {
-                    watchObj.nodesId.delete(authorityNodeId);
-                    parentPathsToWatch.add(path);
+            let parentRemotePathsToUnwatch = new Set<string>();
+            let parentPathsToRewatch = new Set<string>();
+            for (let [cleanPath, watchObj] of this.remoteWatchParents2) {
+                let ranges = watchObj.ranges.filter(x => x.authorityId === authorityNodeId);
+                watchObj.ranges = watchObj.ranges.filter(x => x.authorityId !== authorityNodeId);
+                if (watchObj.ranges.length === 0) {
+                    this.remoteWatchParents2.delete(cleanPath);
+                }
+                for (let range of ranges) {
+                    for (let inputPath of range.inputPaths) {
+                        parentPathsToRewatch.add(inputPath);
+                    }
+                    parentRemotePathsToUnwatch.add(range.finalPath);
                 }
             }
             let paths = Array.from(pathsToWatch);
-            let parentPaths = Array.from(parentPathsToWatch);
 
-            logErrors(RemoteWatcher.REMOTE_UNWATCH_FUNCTION({ paths, parentPaths }, authorityNodeId));
+            logErrors(RemoteWatcher.REMOTE_UNWATCH_FUNCTION({
+                paths,
+                parentPaths: Array.from(parentRemotePathsToUnwatch)
+            }, authorityNodeId));
             this.internalWatchLatest({
                 paths: Array.from(pathsToWatch),
-                parentPaths: Array.from(parentPathsToWatch),
+                parentPaths: Array.from(parentPathsToRewatch),
                 debugName: "refreshAllWatches",
             });
         });
@@ -641,15 +669,26 @@ export class RemoteWatcher {
 
     public getWatchReason(path: string): "direct" | "parent" | undefined {
         if (this.remoteWatchPaths.has(path)) return "direct";
-        if (this.remoteWatchParents.has(getParentPathStr(path))) return "parent";
+        if (this.remoteWatchParents2.has(getParentPathStr(path))) return "parent";
         return undefined;
     }
 }
 
+registerGetSpecForChildPath(path => {
+    if (!PathRouter.isSelfAuthority(path)) {
+        // Depends on the remote authority for this path
+        let remoteWatchRange = remoteWatcher.getRemoteWatchParentRange(path);
+        if (remoteWatchRange) return remoteWatchRange.authoritySpec;
+
+        // NOTE: This fall through usually means that we received a value before we started watching it, which is weird. That really shouldn't happen often. It'll probably break things. We will probably ignore this value thinking it has a different hash than it does.
+        console.warn(`We do not own a path, but also aren't watching it on a remote, but... receive the value? This is weird, and will probably break things (we will likely ignore this value / not trigger parent watches for it).`, { path });
+    }
+    return authorityLookup.getOurSpec();
+});
+
 export const remoteWatcher = new RemoteWatcher();
 (globalThis as any).remoteWatcher = remoteWatcher;
 void Promise.resolve().finally(() => {
     pathWatcher.setUnwatchCallback(config => remoteWatcher.unwatchLatest(config));
     pathWatcher.setWatchRemoteCallback(config => remoteWatcher.watchLatest(config));
-    authorityStorage.setGetMultiNodesForParent(path => remoteWatcher.getMultiNodesForParent(path));
 });

package/src/1-path-client/pathValueClientWatcher.ts

@@ -14,29 +14,24 @@
             - For knowing when values change
  */
 
-import { SocketFunction } from "socket-function/SocketFunction";
-import { cache, lazy } from "socket-function/src/caching";
-import { binarySearchIndex, isNode, recursiveFreeze, sort } from "socket-function/src/misc";
+import { lazy } from "socket-function/src/caching";
+import { isNode } from "socket-function/src/misc";
 import { logErrors } from "../errors";
 import { getParentPathStr, getPathFromStr, hack_stripPackedPath } from "../path";
 import { measureBlock, measureFnc } from "socket-function/src/profiling/measure";
-import { pathValueCommitter, PathValueController } from "../0-path-value-core/PathValueController";
+import { pathValueCommitter } from "../0-path-value-core/PathValueController";
 import { PathValue, Value, getNextTime, Time, ReadLock, MAX_CHANGE_AGE, authorityStorage, getCreatorId, WatchConfig } from "../0-path-value-core/pathValueCore";
 import { pathWatcher } from "../0-path-value-core/PathWatcher";
 import { blue, green, red } from "socket-function/src/formatting/logColors";
-import { MaybePromise } from "socket-function/src/types";
-import { batchFunction, batchFunctionNone, runInfinitePoll } from "socket-function/src/batching";
+import { runInfinitePoll } from "socket-function/src/batching";
 import { registerResource } from "../diagnostics/trackResources";
-import debugbreak from "debugbreak";
-import { ActionsHistory } from "../diagnostics/ActionsHistory";
-import { getOwnNodeId, isOwnNodeId } from "../-f-node-discovery/NodeDiscovery";
+import { getOwnNodeId } from "../-f-node-discovery/NodeDiscovery";
 import { PromiseObj } from "../promise";
 import { getOwnMachineId } from "../-a-auth/certs";
 import { remoteWatcher } from "./RemoteWatcher";
 import { heapTagObj } from "../diagnostics/heapTag";
 import { isDevDebugbreak } from "../config";
-import { auditLog } from "../0-path-value-core/auditLogs";
-import { decodeParentFilter, matchesParentRangeFilter } from "../0-path-value-core/hackedPackedPathParentFiltering";
+import { matchesParentRangeFilter } from "../0-path-value-core/hackedPackedPathParentFiltering";
 
 const pathValueCtor = heapTagObj("PathValue");
 

package/src/2-proxy/pathValueProxy.ts

@@ -1,10 +1,9 @@
 import { runInfinitePoll } from "socket-function/src/batching";
 import { cache, lazy } from "socket-function/src/caching";
 import { appendToPathStr, rootPathStr } from "../path";
-import { MAX_CHANGE_AGE } from "../0-path-value-core/pathValueCore";
 import { runCodeWithDatabase } from "./pathDatabaseProxyBase";
 import { canHaveChildren } from "socket-function/src/types";
-import { isNode } from "socket-function/src/misc";
+import { isNode, timeInMinute } from "socket-function/src/misc";
 
 let noopProxy = createPathValueProxy({ getCallback: () => undefined, setCallback: () => { }, getSymbol: () => undefined, getKeys: () => [] });
 let gettingPath: { value: string } | undefined;
@@ -67,7 +66,7 @@ export function createPathValueProxy(
     let createdCount = 0;
     let createProxyCached = cache(createProxy);
     let proxyClearLoop = lazy(() => {
-        runInfinitePoll(MAX_CHANGE_AGE, function clearProxyCache() {
+        runInfinitePoll(timeInMinute * 5, function clearProxyCache() {
             // TODO: Maybe allow proxies to stick around?
             //if (createdCount > 1000 * 100)
             {

package/src/3-path-functions/PathFunctionRunner.ts

@@ -37,8 +37,10 @@ export const functionSchema = rawSchema<{
         };
     };
 }>();
-void Promise.resolve().then(() => {
+// NOTE: Looks like set immediate will run after even dynamic imports. So this should actually run as late as possible. If not, we might need to make this so the code that's looking for prefixes explicitly asks for the dynamic prefixes when it's ready. 
+setImmediate(() => {
     for (let moduleId of getAllDevelopmentModulesIds()) {
+        addRoutingPrefixForDeploy(getProxyPath(() => functionSchema()[getDomain()].PathFunctionRunner[moduleId].Sources));
         addRoutingPrefixForDeploy(getProxyPath(() => functionSchema()[getDomain()].PathFunctionRunner[moduleId].Calls));
         addRoutingPrefixForDeploy(getProxyPath(() => functionSchema()[getDomain()].PathFunctionRunner[moduleId].Results));
     }