querysub 0.508.0 → 0.509.0

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

@@ -9,9 +9,7 @@ import { pathValueSerializer } from "../-h-path-value-serialize/PathValueSeriali
 import { pathValueCommitter } from "./PathValueCommitter";
 import { auditLog, isDebugLogEnabled } from "./auditLogs";
 import { debugNodeId, debugNodeThread } from "../-c-identity/IdentityController";
-import { getSlowdown, isDiskAudit, getDomain, DEFAULT_NETWORK } from "../config";
-import { getPathNetwork } from "./PathRouterRouteOverride";
-import { decodeParentFilter } from "./hackedPackedPathParentFiltering";
+import { getSlowdown, isDiskAudit, getDomain } from "../config";
 import { decodeNodeId } from "sliftutils/misc/https/certs";
 import { areNodeIdsEqual, isOwnNodeId } from "../-f-node-discovery/NodeDiscovery";
 import { getNodeIdIP } from "socket-function/src/nodeCache";
@@ -235,10 +233,10 @@ export class PathValueControllerBase {
         if (isDebugLogEnabled()) {
             let sourceNodeId = debugNodeId(callerId);
             for (let value of config.paths) {
-                auditLog("WATCH PATH", { path: value, network: getPathNetwork(value), sourceNodeId, sourceNodeThreadId: debugNodeThread(callerId) });
+                auditLog("WATCH PATH", { path: value, sourceNodeId, sourceNodeThreadId: debugNodeThread(callerId) });
             }
             for (let value of config.parentPaths) {
-                auditLog("WATCH PARENT PATH", { path: value, network: decodeParentFilter(value)?.network || DEFAULT_NETWORK, sourceNodeId });
+                auditLog("WATCH PARENT PATH", { path: value, sourceNodeId });
             }
         }
         pathWatcher.watchPath({
@@ -254,10 +252,10 @@ export class PathValueControllerBase {
         if (isDebugLogEnabled()) {
             let sourceNodeId = debugNodeId(SocketFunction.getCaller().nodeId);
             for (let value of config.paths) {
-                auditLog("UNWATCHING PATH", { path: value, network: getPathNetwork(value), sourceNodeId, sourceNodeThreadId: debugNodeThread(callerId) });
+                auditLog("UNWATCHING PATH", { path: value, sourceNodeId, sourceNodeThreadId: debugNodeThread(callerId) });
             }
             for (let value of config.parentPaths) {
-                auditLog("UNWATCHING PARENT PATH", { path: value, network: decodeParentFilter(value)?.network || DEFAULT_NETWORK, sourceNodeId });
+                auditLog("UNWATCHING PARENT PATH", { path: value, sourceNodeId });
             }
         }
         pathWatcher.unwatchPath({ paths: config.paths, parentPaths: config.parentPaths, callback: callerId, reason: "PathValueController.unwatchLatest" });

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

@@ -11,9 +11,7 @@ import { PathValueControllerBase } from "./PathValueController";
 import { PathRouter } from "./PathRouter";
 import { auditLog } from "./auditLogs";
 import { WatchConfig, authorityStorage, PathValue, NodeId, compareTime, isCoreQuiet, MAX_CHANGE_AGE, createMissingEpochValue } from "./pathValueCore";
-import { decodeParentFilter, matchesParentRangeFilter } from "./hackedPackedPathParentFiltering";
-import { getPathNetwork } from "./PathRouterRouteOverride";
-import { DEFAULT_NETWORK } from "../config";
+import { matchesParentRangeFilter } from "./hackedPackedPathParentFiltering";
 import { isClient } from "../config2";
 import { delay } from "socket-function/src/batching";
 import { isClientNodeId } from "socket-function/src/nodeCache";
@@ -172,22 +170,21 @@ class PathWatcher {
             incrementWatcherSequence();
             if (isOwnNodeId(config.nodeId)) {
                 for (let path of newPathsWatched) {
-                    auditLog("new local WATCH VALUE", { path, network: getPathNetwork(path) });
+                    auditLog("new local WATCH VALUE", { path });
                 }
                 for (let path of newParentsWatched) {
-                    auditLog("new local WATCH PARENT", { path, network: decodeParentFilter(path)?.network || DEFAULT_NETWORK });
+                    auditLog("new local WATCH PARENT", { path });
                 }
             } else {
                 for (let path of newPathsWatched) {
                     auditLog("new non-local WATCH VALUE", {
                         path,
-                        network: getPathNetwork(path),
                         watcher: config.nodeId,
                         sourceNodeThreadId: debugNodeThread(config.nodeId),
                     });
                 }
                 for (let path of newParentsWatched) {
-                    auditLog("new non-local WATCH PARENT", { path, network: decodeParentFilter(path)?.network || DEFAULT_NETWORK, watcher: config.nodeId });
+                    auditLog("new non-local WATCH PARENT", { path, watcher: config.nodeId });
                 }
             }
             console.info(`New PathValue watches`, {
@@ -247,9 +244,9 @@ class PathWatcher {
             obj.watchers.delete(callback);
 
             if (isOwnNodeId(callback)) {
-                auditLog("local UNWATCH PARENT", { path, network: decodeParentFilter(path)?.network || DEFAULT_NETWORK, reason, remainingWatchers: obj.watchers.size });
+                auditLog("local UNWATCH PARENT", { path, reason, remainingWatchers: obj.watchers.size });
             } else {
-                auditLog("non-local UNWATCH PARENT", { path, network: decodeParentFilter(path)?.network || DEFAULT_NETWORK, watcher: callback, remoteNodeId: debugNodeId(callback), remoteNodeThreadId: debugNodeThread(callback), reason, remainingWatchers: obj.watchers.size });
+                auditLog("non-local UNWATCH PARENT", { path, watcher: callback, remoteNodeId: debugNodeId(callback), remoteNodeThreadId: debugNodeThread(callback), reason, remainingWatchers: obj.watchers.size });
             }
 
             if (obj.watchers.size === 0) {
@@ -284,9 +281,9 @@ class PathWatcher {
             watchers.watchers.delete(callback);
 
             if (isOwnNodeId(callback)) {
-                auditLog("local UNWATCH VALUE", { path, network: getPathNetwork(path), reason });
+                auditLog("local UNWATCH VALUE", { path, reason });
             } else {
-                auditLog("non-local UNWATCH VALUE", { path, network: getPathNetwork(path), watcher: callback, reason });
+                auditLog("non-local UNWATCH VALUE", { path, watcher: callback, reason });
             }
 
             if (watchers.watchers.size === 0) {

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

@@ -3,8 +3,6 @@ import { getPathDepth, getPathIndexAssert, hack_getPackedPathSuffix, hack_setPac
 import { AuthoritySpec, PathRouter } from "./PathRouter";
 import { cache } from "socket-function/src/caching";
 import { authorityLookup } from "./AuthorityLookup";
-import { assertValidNetwork, getPathNetwork } from "./PathRouterRouteOverride";
-import { DEFAULT_NETWORK } from "../config";
 
 
 let getSpecForChildPath = (path: string) => authorityLookup.getOurSpec();
@@ -18,14 +16,9 @@ export function matchesParentRangeFilter(config: {
     packedPath: string;
 }) {
     // If it equals the non packed path, then it must not be packed, and so it must match.
-    if (config.parentPath === config.packedPath) {
-        return getPathNetwork(config.fullPath) === DEFAULT_NETWORK;
-    }
+    if (config.parentPath === config.packedPath) return true;
     let filter = decodeParentFilter(config.packedPath);
-    if (!filter) {
-        return getPathNetwork(config.fullPath) === DEFAULT_NETWORK;
-    }
-    if (getPathNetwork(config.fullPath) !== (filter.network || DEFAULT_NETWORK)) return false;
+    if (!filter) return true;
     if (filter.start <= 0 && filter.end >= 1) return true;
     let route = PathRouter.getRouteFull({ path: config.fullPath, spec: getSpecForChildPath(config.fullPath) });
     return filter.start <= route && route < filter.end;
@@ -33,14 +26,12 @@ export function matchesParentRangeFilter(config: {
 
 export const filterChildPathsBase = measureWrap(
     function filterChildPathsBase(parentPath: string, packedSuffix: string, paths: Set<string>): Set<string> {
-        let [startFractionStr, endFractionStr, network] = packedSuffix.split("|");
+        let [startFractionStr, endFractionStr] = packedSuffix.split("|");
         let startFraction = Number(startFractionStr);
         let endFraction = Number(endFractionStr);
-        let filterNetwork = network || DEFAULT_NETWORK;
 
         let filtered = new Set<string>();
         for (let path of paths) {
-            if (getPathNetwork(path) !== filterNetwork) continue;
             // TODO: We can make this significantly more efficient as once we know if it's a prefix or not, we know the underlying function call every time. However, that starts to get complicated, and I don't think this is going to be a bottleneck.
             let route = PathRouter.getRouteFull({ path, spec: getSpecForChildPath(path) });
             if (startFraction <= route && route < endFraction) {
@@ -56,19 +47,14 @@ export function encodeParentFilter(config: {
     path: string;
     startFraction: number;
     endFraction: number;
-    network?: string;
 }) {
-    let suffix = `${config.startFraction}|${config.endFraction}`;
-    if (config.network) {
-        assertValidNetwork(config.network);
-        suffix += `|${config.network}`;
-    }
-    return hack_setPackedPathSuffix(config.path, suffix);
+    return hack_setPackedPathSuffix(config.path, `${config.startFraction}|${config.endFraction}`);
 }
-export function decodeParentFilter(path: string): { path: string; start: number, end: number; network?: string } | undefined {
+export function decodeParentFilter(path: string): { path: string; start: number, end: number } | undefined {
     let packedSuffix = hack_getPackedPathSuffix(path);
     if (!packedSuffix) return undefined;
-    let [startStr, endStr, network] = packedSuffix.split("|");
+    let [startStr, endStr] = packedSuffix.split("|");
     let unpackedPath = hack_stripPackedPath(path);
-    return { path: unpackedPath, start: Number(startStr), end: Number(endStr), network: network || undefined };
+    return { path: unpackedPath, start: Number(startStr), end: Number(endStr) };
+
 }

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

@@ -24,8 +24,7 @@ import { fastHash } from "../misc/hash";
 import { authorityLookup } from "./AuthorityLookup";
 import { onPathInteracted } from "../diagnostics/pathAuditerCallback";
 import { decodeParentFilter, filterChildPathsBase } from "./hackedPackedPathParentFiltering";
-import { getPathNetwork } from "./PathRouterRouteOverride";
-import { isDiskAudit, DEFAULT_NETWORK } from "../config";
+import { isDiskAudit } from "../config";
 import { removeRange } from "../rangeMath";
 import { remoteWatcher } from "../1-path-client/RemoteWatcher";
 import { setFlag } from "socket-function/require/compileFlags";
@@ -570,14 +569,14 @@ class AuthorityPathValueStorage {
         if (this.DEBUG_UNWATCH) {
             console.log(blue(`Unsyncing path at ${Date.now()}`), path);
         }
-        auditLog("DESTROY PATH", { path, network: getPathNetwork(path) });
+        auditLog("DESTROY PATH", { path });
 
         this.isSyncedCache.delete(path);
         this.removePathFromStorage(path, "unwatched");
     }
     public markParentPathAsUnwatched(path: string) {
         if (this.parentsSynced.has(path)) {
-            console.info(`Unwatching path that is a parent synced path (fine, but might be an issue)`, { path, network: decodeParentFilter(path)?.network || DEFAULT_NETWORK });
+            console.info(`Unwatching path that is a parent synced path (fine, but might be an issue)`, { path });
         }
         // NOTE: I don't think we have to handle the case where we are the authority,
         //  because we don't delete any actual data here.
@@ -696,7 +695,7 @@ class AuthorityPathValueStorage {
     public addParentSyncs(parentSyncs: { parentPath: string; sourceNodeId: string }[]) {
         for (let obj of parentSyncs) {
             if (isDebugLogEnabled()) {
-                auditLog("RECEIVED PARENT PATH", { parentPath: obj.parentPath, network: decodeParentFilter(obj.parentPath)?.network || DEFAULT_NETWORK, remoteNodeId: debugNodeId(obj.sourceNodeId), remoteNodeThreadId: debugNodeThread(obj.sourceNodeId) });
+                auditLog("RECEIVED PARENT PATH", { parentPath: obj.parentPath, remoteNodeId: debugNodeId(obj.sourceNodeId), remoteNodeThreadId: debugNodeThread(obj.sourceNodeId) });
             }
 
             let decoded = decodeParentFilter(obj.parentPath);

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

@@ -2,7 +2,7 @@
 import { SocketFunction } from "socket-function/SocketFunction";
 import { batchFunction, runInSerial, runInfinitePoll } from "socket-function/src/batching";
 import { cache } from "socket-function/src/caching";
-import { isNode, sort } from "socket-function/src/misc";
+import { isNode, sort, timeInMinute, timeInSecond } from "socket-function/src/misc";
 import { measureFnc, measureBlock } from "socket-function/src/profiling/measure";
 import { getOwnNodeId, isOwnNodeId } from "../-f-node-discovery/NodeDiscovery";
 import { PathValueController } from "../0-path-value-core/PathValueController";
@@ -20,8 +20,6 @@ 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, registerGetSpecForChildPath } from "../0-path-value-core/hackedPackedPathParentFiltering";
-import { getPathNetwork } from "../0-path-value-core/PathRouterRouteOverride";
-import { DEFAULT_NETWORK } from "../config";
 import { removeRange, rangesOverlap } from "../rangeMath";
 import { evaluateValidStates } from "../config2";
 
@@ -30,6 +28,10 @@ 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.
 const STOP_KEYS_DOUBLE_SENDS = true;
 
+// How close to an authority's scheduled shutdown we start treating it like a disconnect (rehoming all the paths we watch on it).
+const SHUTDOWN_REHOME_WINDOW = timeInMinute * 5;
+const SHUTDOWN_REHOME_POLL_INTERVAL = timeInSecond * 30;
+
 // NOTE: If a parent watch is broken up between multiple nodes, we generally watch everything on all those nodes and then filter when we receive the data. This isn't efficient, and we should probably change it. However, in practice, it's probably fine, as it's unlikely for the watches to be broken up to a much finer granularity than the network (it would require very strange partially overlapping sharding cases which no reasonable sharding setup would ever satisfy).
 export class RemoteWatcher {
     public static DEBUG = false;
@@ -48,10 +50,8 @@ export class RemoteWatcher {
             start: number;
             // exclusive
             end: number;
-            // encodeParentFilter({ path: cleanPath, startFraction: start, endFraction: end, network })
+            // encodeParentFilter({ path: cleanPath, startFraction: start, endFraction: end })
             finalPath: string;
-            // undefined means the default network
-            network?: string;
             // All of the requests paths that request it (pre decodeParentFilter).
             inputPaths: Set<string>;
 
@@ -126,6 +126,32 @@ export class RemoteWatcher {
     //      the chances the server will be useless is high, so... lag is probably fine in exchange for faster
     //      reconnection.
     private reconnectLoop = runInfinitePoll(10000, () => this.tryToReconnectNow());
+
+    // Once an authority is this close to its scheduled shutdown, we act as if it disconnected, and find new homes for all the paths we watch on it (PathRouter avoids shutting down nodes, so the rewatch picks a different authority when one exists).
+    private rehomedShutdownNodes = new Set<string>();
+    private shutdownRehomeLoop = runInfinitePoll(SHUTDOWN_REHOME_POLL_INTERVAL, () => this.rehomeShuttingDownAuthorities());
+    private rehomeShuttingDownAuthorities() {
+        let authorityIds = new Set<string>(this.remoteWatchPaths.values());
+        for (let watchObj of this.remoteWatchParents2.values()) {
+            for (let range of watchObj.ranges) {
+                authorityIds.add(range.authorityId);
+            }
+        }
+        for (let authorityId of authorityIds) {
+            if (this.rehomedShutdownNodes.has(authorityId)) continue;
+            let shutdownTime = authorityLookup.getScheduledShutdownTime(authorityId);
+            if (shutdownTime === undefined || shutdownTime - Date.now() > SHUTDOWN_REHOME_WINDOW) continue;
+            this.rehomedShutdownNodes.add(authorityId);
+            console.log(yellow(`Authority ${authorityId} is scheduled to shut down at ${new Date(shutdownTime).toLocaleString()}, rehoming all paths watched on it`));
+            logErrors(this.refreshAllWatches(authorityId));
+        }
+        // Nodes we no longer watch don't need an entry (otherwise this grows forever, as every switchover shuts down a node)
+        for (let nodeId of Array.from(this.rehomedShutdownNodes)) {
+            if (!authorityIds.has(nodeId)) {
+                this.rehomedShutdownNodes.delete(nodeId);
+            }
+        }
+    }
     private async tryToReconnectNow() {
         if (!this.disconnectedPaths.size && !this.disconnectedParents.size) return;
 
@@ -143,10 +169,8 @@ export class RemoteWatcher {
         let parentPath = getParentPathStr(path);
         let watchObj = this.remoteWatchParents2.get(parentPath);
         if (!watchObj) return undefined;
-        let pathNetwork = getPathNetwork(path);
         // 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 => {
-            if ((x.network || DEFAULT_NETWORK) !== pathNetwork) return false;
             let route = PathRouter.getRouteFull({ path, spec: x.authoritySpec });
             return x.start <= route && route < x.end;
         });
@@ -155,10 +179,8 @@ export class RemoteWatcher {
         let parentPath = getParentPathStr(path);
         let watchObj = this.remoteWatchParents2.get(parentPath);
         if (!watchObj) return undefined;
-        let pathNetwork = getPathNetwork(path);
         // 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.
         for (let range of watchObj.ranges) {
-            if ((range.network || DEFAULT_NETWORK) !== pathNetwork) continue;
             let route = PathRouter.getRouteFull({ path, spec: range.authoritySpec });
             if (range.start <= route && route < range.end) {
                 return route;
@@ -266,17 +288,17 @@ export class RemoteWatcher {
                     if (totalMissingPaths === 0) {
                         let authorities = authorityLookup.getTopologySync();
                         authorityId = PathRouter.getReadyAuthority(path)?.nodeId;
-                        console.warn(`Missing authority for path ${path} (network ${getPathNetwork(path)})`, { network: getPathNetwork(path), authorities });
+                        console.warn(`Missing authority for path ${path}`, { authorities });
                     }
                     totalMissingPaths++;
                     if (!this.disconnectedPaths.has(path)) {
                         newDisconnectPaths++;
                         this.disconnectedPaths.add(path);
-                        auditLog("NO AUTHORITY FOR PATH", { path, network: getPathNetwork(path) });
+                        auditLog("NO AUTHORITY FOR PATH", { path });
                     }
                     continue;
                 }
-                auditLog("FOUND AUTHORITY FOR PATH", { path, network: getPathNetwork(path), authorityId });
+                auditLog("FOUND AUTHORITY FOR PATH", { path, authorityId });
                 this.disconnectedPaths.delete(path);
                 foundPaths++;
 
@@ -297,7 +319,6 @@ export class RemoteWatcher {
 
                 let decodedParentFilter = decodeParentFilter(path);
                 let cleanPath = decodedParentFilter?.path ?? path;
-                let network = decodedParentFilter?.network;
 
                 let rangeStart = 0;
                 let rangeEnd = 1;
@@ -306,8 +327,6 @@ export class RemoteWatcher {
                     rangeEnd = decodedParentFilter.end;
                 }
 
-                const sameNetwork = (rangeNetwork: string | undefined) => (rangeNetwork || DEFAULT_NETWORK) === (network || DEFAULT_NETWORK);
-
                 let watchObj = this.remoteWatchParents2.get(cleanPath);
 
                 if (watchObj && !config.tryReconnect) {
@@ -317,13 +336,11 @@ export class RemoteWatcher {
                         end: rangeEnd,
                     }];
                     for (let range of watchObj.ranges) {
-                        if (!sameNetwork(range.network)) continue;
                         removeRange(requiredRanges, range);
                     }
                     if (requiredRanges.length === 0) {
                         this.disconnectedParents.delete(path);
                         for (let range of watchObj.ranges) {
-                            if (!sameNetwork(range.network)) continue;
                             if (rangesOverlap(range, { start: rangeStart, end: rangeEnd })) {
                                 range.inputPaths.add(path);
                             }
@@ -332,8 +349,7 @@ export class RemoteWatcher {
                     }
                 }
 
-                let readNodesPath = network && encodeParentFilter({ path: cleanPath, startFraction: 0, endFraction: 1, network }) || cleanPath;
-                let { nodes } = PathRouter.getChildReadNodes(readNodesPath, {
+                let { nodes } = PathRouter.getChildReadNodes(cleanPath, {
                     // Pass existing connected node ids as preferred
                     preferredNodeIds: watchObj?.ranges.map(x => x.authorityId) || []
                 });
@@ -361,7 +377,6 @@ export class RemoteWatcher {
                 // 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) {
-                    if (!sameNetwork(range.network)) continue;
                     removeRange(missingRanges, range);
                 }
 
@@ -374,14 +389,13 @@ export class RemoteWatcher {
                         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, network });
+                        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,
-                                network,
                                 inputPaths: new Set(),
                                 authorityId: node.nodeId,
                                 suppressedWatches: new Set(),
@@ -401,7 +415,6 @@ export class RemoteWatcher {
 
                 // Register path on pre-existing ranges that already cover parts of [rangeStart, rangeEnd]
                 for (let range of watchObj.ranges) {
-                    if (!sameNetwork(range.network)) continue;
                     if (rangesOverlap(range, { start: rangeStart, end: rangeEnd })) {
                         range.inputPaths.add(path);
                     }
@@ -413,7 +426,7 @@ export class RemoteWatcher {
             console.warn(`Some paths have no authority. We will search for an authority periodically until we find an authority. New missing ${newDisconnectPaths} paths and ${newDisconnectParents} parent paths, total missing ${this.disconnectedPaths.size} paths and ${this.disconnectedParents.size} parent paths.`);
             let first10 = Array.from(this.disconnectedPaths).slice(0, 10);
             for (let path of first10) {
-                console.log(`\t(network ${getPathNetwork(path)}) ${path}`);
+                console.log(`\t${path}`);
             }
             if (this.disconnectedPaths.size > 10) {
                 console.log(`\t... and ${this.disconnectedPaths.size - 10} more paths`);
@@ -433,10 +446,10 @@ export class RemoteWatcher {
             if (isOwnNodeId(authorityId)) continue;
 
             for (let path of paths) {
-                auditLog("remoteWatcher outer WATCH", { path, network: getPathNetwork(path), remoteNodeId: authorityId });
+                auditLog("remoteWatcher outer WATCH", { path, remoteNodeId: authorityId });
             }
             for (let path of parentPaths) {
-                auditLog("remoteWatcher outer PARENT WATCH", { path, network: decodeParentFilter(path)?.network || DEFAULT_NETWORK, remoteNodeId: authorityId });
+                auditLog("remoteWatcher outer PARENT WATCH", { path, remoteNodeId: authorityId });
             }
 
             if (STOP_KEYS_DOUBLE_SENDS) {
@@ -445,7 +458,7 @@ export class RemoteWatcher {
                     let range = this.getRemoteWatchParentRange(path);
                     if (range) {
                         range.suppressedWatches.add(path);
-                        auditLog("remoteWatcher outer WATCH SUPPRESSED", { path, network: getPathNetwork(path), remoteNodeId: authorityId });
+                        auditLog("remoteWatcher outer WATCH SUPPRESSED", { path, remoteNodeId: authorityId });
                         return false;
                     }
                     return true;
@@ -497,10 +510,10 @@ export class RemoteWatcher {
                 }
                 for (let [authorityId, { paths, parentPaths }] of byAuthority) {
                     for (let path of paths) {
-                        auditLog("remoteWatcher inner WATCH", { path, network: getPathNetwork(path), remoteNodeId: authorityId });
+                        auditLog("remoteWatcher inner WATCH", { path, remoteNodeId: authorityId });
                     }
                     for (let path of parentPaths) {
-                        auditLog("remoteWatcher inner WATCH PARENT", { path, network: decodeParentFilter(path)?.network || DEFAULT_NETWORK, remoteNodeId: authorityId });
+                        auditLog("remoteWatcher inner WATCH PARENT", { path, remoteNodeId: authorityId });
                     }
                     // NOTE: We log watches here because we want to log batched watches
                     ActionsHistory.OnNewWatches({ newPathsWatched: paths, newParentsWatched: parentPaths, debugName: batched[0].debugName, authorityId });
@@ -511,10 +524,10 @@ export class RemoteWatcher {
                     };
                     if (isDebugLogEnabled()) {
                         for (let path of paths) {
-                            auditLog("Asking to watch path", { path, network: getPathNetwork(path), authorityId, targetNodeThreadId: debugNodeThread(authorityId) });
+                            auditLog("Asking to watch path", { path, authorityId, targetNodeThreadId: debugNodeThread(authorityId) });
                         }
                         for (let path of parentPaths) {
-                            auditLog("Asking to watch parent path", { path, network: decodeParentFilter(path)?.network || DEFAULT_NETWORK, authorityId, targetNodeThreadId: debugNodeThread(authorityId) });
+                            auditLog("Asking to watch parent path", { path, authorityId, targetNodeThreadId: debugNodeThread(authorityId) });
                         }
                     }
                     logErrors(RemoteWatcher.REMOTE_WATCH_FUNCTION(config, authorityId));
@@ -604,10 +617,10 @@ export class RemoteWatcher {
         }
         for (let [authorityIdBase, { paths, parentPaths }] of unwatchesPerAuthority.entries()) {
             for (let path of paths) {
-                auditLog("remoteWatcher inner UNWATCH", { path, network: getPathNetwork(path), remoteNodeId: authorityIdBase });
+                auditLog("remoteWatcher inner UNWATCH", { path, remoteNodeId: authorityIdBase });
             }
             for (let path of parentPaths) {
-                auditLog("remoteWatcher inner UNWATCH PARENT", { path, network: decodeParentFilter(path)?.network || DEFAULT_NETWORK, remoteNodeId: authorityIdBase });
+                auditLog("remoteWatcher inner UNWATCH PARENT", { path, remoteNodeId: authorityIdBase });
             }
             if (!isOwnNodeId(authorityIdBase)) {
                 logErrors(RemoteWatcher.REMOTE_UNWATCH_FUNCTION({ paths, parentPaths }, authorityIdBase));

package/src/2-proxy/archiveMoveHarness.ts

@@ -178,7 +178,8 @@ export async function runArchiveMover(config: {
                             excludedValues.push(value);
                         }
                     }
-                    if (includedValues.length === 0) {
+                    // If we are excluding it because we're filtering it, then there's no reason to rewrite the file. HOWEVER, If the file is empty, which can happen if it's corrupted, then we should move the file. Otherwise, corrupted files never get moved by anything. 
+                    if (includedValues.length === 0 && valuesObj.values.length > 0) {
                         continue;
                     }
                     if (excludedValues.length > 0) {

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

@@ -18,8 +18,14 @@ import { interceptCalls } from "../-0-hooks/hooks";
 import { createRoutingOverrideKey } from "../0-path-value-core/PathRouterRouteOverride";
 import { PathRouter } from "../0-path-value-core/PathRouter";
 import { getPathFromProxy } from "../2-proxy/pathValueProxy";
-import { getDomain, getPrimaryNetwork, isPublic, DEFAULT_NETWORK } from "../config";
+import { getDomain, isPublic } from "../config";
 import { isServer } from "../config2";
+
+// Deferred, as syncSchema.ts imports us at module init, and FunctionRunnerTracking imports syncSchema.
+let functionRunnerTracking: typeof import("../4-querysub/FunctionRunnerTracking") | undefined;
+setImmediate(async () => {
+    functionRunnerTracking = await import("../4-querysub/FunctionRunnerTracking");
+});
 import { getTimeUnique } from "socket-function/src/bits";
 
 // NOTE: We could deploy single functions, but... we will almost always be updating all functions at
@@ -160,14 +166,11 @@ export function writeFunctionCall(config: {
     //          which gives them about a minute to guess it...
     let callId = now + "_" + secureRandom();
 
-    // Clients don't know their network. The QuerysubController decides the network for their calls (and rewrites the callId to match).
-    let network: string | undefined;
-    if (isNode()) {
-        network = getPrimaryNetwork();
-        if (network === DEFAULT_NETWORK) {
-            network = undefined;
-        }
+    // The CALLER has to pick the network (instead of the receiving server), because the caller needs to watch the call's result path (which the network is part of) ahead of time — that is how predictions work.
+    if (!functionRunnerTracking) {
+        throw new Error(`Function runner tracking is not loaded yet, so a network cannot be picked for the call ${moduleId}.${functionId}`);
     }
+    let network = functionRunnerTracking.getSelectedNetwork();
 
     // We HAVE to override the routing id, otherwise PathFunctionRunner secondary sharding won't work
     callId = getCallIdOverride({
@@ -175,12 +178,10 @@ export function writeFunctionCall(config: {
         functionId,
         callId,
         args,
-        network,
     }) || createRoutingOverrideKey({
         originalKey: callId,
         routeKey: callId,
         remappedPrefix: getFunctionRunnerPrefix(moduleId),
-        network,
     });
 
     let argsEncoded = encodeArgs(args);