querysub 0.406.0 → 0.407.0

package/bin/deploy-prefixes.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+
+// Always local, as we want to always use the local code? Might not be needed anymore?
+process.argv.push("--local");
+
+require("typenode");
+require("../src/4-deploy/deployPrefixes");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.406.0",
+  "version": "0.407.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
@@ -23,6 +23,7 @@
   },
   "bin": {
     "deploy": "./bin/deploy.js",
+    "deploy-prefixes": "./bin/deploy-prefixes.js",
     "server": "./bin/server.js",
     "server-public": "./bin/server-public.js",
     "function": "./bin/function.js",

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

@@ -46,8 +46,6 @@ let DISK_AUDIT_RATE = timeInMinute * 15;
 //  probably is less than that). Which is around 2.5 cents on digital ocean IF we go over
 //  our 1TB/month allowance.
 let API_AUDIT_RATE = timeInSecond * 30;
-// BUT, for now, poll less often... because I think it is lagging our 2 core potato digital ocean server.
-API_AUDIT_RATE = timeInMinute * 5;
 let API_AUDIT_COUNT = 12;
 
 

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

@@ -5,7 +5,7 @@ import { archiveJSONT } from "../-a-archives/archivesJSONT";
 import { getDomain, isPublic } from "../config";
 import { cache, lazy } from "socket-function/src/caching";
 import { SocketFunction } from "socket-function/SocketFunction";
-import { runInSerial, runInfinitePollCallAtStart } from "socket-function/src/batching";
+import { delay, runInSerial, runInfinitePollCallAtStart } from "socket-function/src/batching";
 import { getAllNodeIds, getOwnNodeId, isOwnNodeId, onNodeBroadcasted, syncNodesNow, watchDeltaNodeIds, watchNodeIds } from "../-f-node-discovery/NodeDiscovery";
 import { IdentityController_getCurrentReconnectNodeIdAssert } from "../-c-identity/IdentityController";
 import { requiresNetworkTrustHook } from "../-d-trust/NetworkTrust2";
@@ -15,6 +15,7 @@ import { timeoutToError } from "../errors";
 import { AuthoritySpec } from "./PathRouter";
 import { formatTime } from "socket-function/src/formatting/format";
 import { getAllAuthoritySpec, getEmptyAuthoritySpec } from "./PathRouterServerAuthoritySpec";
+import { getPrefixesForDeploy } from "../3-path-functions/syncSchema";
 
 
 let NETWORK_POLL_INTERVAL = timeInMinute * 5;
@@ -201,9 +202,13 @@ class AuthorityLookup {
         if (isClient()) {
             // Doesn't matter what the node ID is, we should really only be connecting to the browser node ID, Which will have all the data for the current domain. 
             //  - Get all node IDs should restrict our nodes to just the browser node ID. If we ever change this, then either it's redundant nodes and they all have all the same data, or we need to figure out what data they have, And as their proxies, it probably won't be their actual authority data. So that will require new API functions, etc. 
+            await new Promise(r => setImmediate(r));
+            await delay(1);
             this.updatePaths(nodeId, {
-                ...getAllAuthoritySpec(),
                 nodeId: nodeId,
+                prefixes: await getPrefixesForDeploy(),
+                routeStart: 0,
+                routeEnd: 1,
             }, true);
             return;
         }

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

@@ -9,6 +9,7 @@ import { unique } from "../misc";
 import { measureFnc } from "socket-function/src/profiling/measure";
 import { getRoutingOverride, hasPrefixHash } from "./PathRouterRouteOverride";
 import { sha256 } from "js-sha256";
+import { removeRange } from "../rangeMath";
 
 
 // Cases
@@ -36,6 +37,25 @@ export type AuthoritySpec = {
     excludeDefault?: boolean;
 };
 
+export function debugSpec(spec: AuthoritySpec) {
+    return {
+        info: `${spec.routeStart}-${spec.routeEnd} (${spec.prefixes.length} prefixes${spec.excludeDefault ? " excluding default" : ""})`,
+        spec: { do: { not: { expand: { spec } } } },
+    };
+}
+
+function getMatchingPrefix(spec: AuthoritySpec, path: string): string | undefined {
+    let longestPrefix: string | undefined;
+    for (let prefix of spec.prefixes) {
+        if (path.startsWith(prefix) && prefix !== path) {
+            if (!longestPrefix || longestPrefix.length < prefix.length) {
+                longestPrefix = prefix;
+            }
+        }
+    }
+    return longestPrefix;
+}
+
 
 export class PathRouter {
 
@@ -47,6 +67,10 @@ export class PathRouter {
      */
     @measureFnc
     public static getRouteChildKey(path: string): number {
+        let override = getRoutingOverride(path);
+        if (override) {
+            return override.route;
+        }
         let key = getLastPathPart(path);
         return this.getSingleKeyRoute(key);
     }
@@ -61,11 +85,12 @@ export class PathRouter {
         path = hack_stripPackedPath(path);
         let override = getRoutingOverride(path);
         if (override) {
-            if (!hasPrefixHash({ spec, prefixHash: override.prefixHash })) return -1;
+            if (spec.excludeDefault && !hasPrefixHash({ spec, prefixHash: override.prefixHash })) return -1;
+            if (override.route < spec.routeStart || override.route >= spec.routeEnd) return -1;
             return override.route;
         }
 
-        let prefix = spec.prefixes.find(x => path.startsWith(x) && x !== path);
+        let prefix = getMatchingPrefix(spec, path);
         if (prefix) {
             let key = getPathIndex(path, getPathDepth(prefix));
             if (key === undefined) {
@@ -79,6 +104,17 @@ export class PathRouter {
         return hash;
     }
 
+    // Mostly for debugging
+    @measureFnc
+    public static getAllRoutes(path: string): number[] {
+        let routes: number[] = [];
+        for (let authority of authorityLookup.getTopologySync()) {
+            let route = this.getRouteFull({ path, spec: authority.authoritySpec });
+            routes.push(route);
+        }
+        return routes;
+    }
+
     private static lastKeyRoute = {
         key: "",
         route: -1,
@@ -86,6 +122,12 @@ export class PathRouter {
     // Takes a key which is a part of a path. Mostly used PathRouterRouteOverride, or other PathRouter helpers.
     public static getSingleKeyRoute(key: string): number {
         if (key && this.lastKeyRoute.key === key) return this.lastKeyRoute.route;
+        let override = getRoutingOverride(key);
+        if (override) {
+            this.lastKeyRoute.key = key;
+            this.lastKeyRoute.route = override.route;
+            return override.route;
+        }
         let hash = fastHash(key);
         let route = hash % (1000 * 1000 * 1000) / (1000 * 1000 * 1000);
         this.lastKeyRoute.key = key;
@@ -145,18 +187,11 @@ export class PathRouter {
 
         let prefixes = ourSpec.prefixes.slice();
         sort(prefixes, x => x.length);
-        function getPrefix(path: string): string | undefined {
-            for (let prefix of prefixes) {
-                if (path.startsWith(prefix) && prefix !== path) return prefix;
-            }
-            return undefined;
-        }
-
 
         // NOTE: If there are few enough path values for a prefix, we don't even need to calculate the routing hash. 
         let byPrefix = new Map<string | undefined, PathValue[]>();
         for (let value of values) {
-            let prefix = getPrefix(value.path);
+            let prefix = getMatchingPrefix(ourSpec, value.path);
             let values = byPrefix.get(prefix);
             if (!values) {
                 values = [];
@@ -283,11 +318,12 @@ export class PathRouter {
 
 
     // NOTE: This might return overlapping specs. Presently, this is only used when we're loading our initial data, so it's fine. However, if we use this for another purpose in the future, it might cause problems. So we might need to implement a different function for that theoretical future purpose.
+    // NOTE: Only takes remote nodes as presently this is just used during startup.
     @measureFnc
     public static getAuthoritySources(config: {
         target: AuthoritySpec;
         preferredNodeIds?: string[];
-    }): (AuthoritySpec & { useFullPathHash?: boolean })[] {
+    }): AuthoritySpec[] {
         let { target } = config;
         let allSources = authorityLookup.getTopologySync();
         allSources = allSources.filter(x => !isOwnNodeId(x.nodeId));
@@ -368,41 +404,21 @@ export class PathRouter {
             for (let source of group) {
                 let s = source.routeStart;
                 let e = source.routeEnd;
-                // Find if it overlaps any missing range, and if so, cut out that part of the missing change, and add the nodeId to usedNodeIds
-                for (let i = missingRanges.length - 1; i >= 0; i--) {
-                    let missingRange = missingRanges[i];
-                    if (s >= missingRange.end || e <= missingRange.start) continue;
-                    let startTaken = Math.max(missingRange.start, s);
-                    let endTaken = Math.min(missingRange.end, e);
-                    // NOTE: It's not ideal that we might have to fragment one node ID between multiple requests. However, in practice, there shouldn't be much fragmentation here. The ranges that our nodes are breaking down by should be consistent, so there's actually no overlap or subsets.
+                let { removedRanges } = removeRange(missingRanges, { start: s, end: e });
+                for (let removedRange of removedRanges) {
                     usedParts.push({
                         nodeId: source.nodeId,
-                        routeStart: startTaken,
-                        routeEnd: endTaken,
+                        routeStart: removedRange.start,
+                        routeEnd: removedRange.end,
                         prefixes: target.prefixes,
                         excludeDefault: target.excludeDefault,
-                        useFullPathHash,
                     });
-                    missingRanges.splice(i, 1);
-                    // Add back the parts we didn't overlap
-                    if (missingRange.start < s) {
-                        missingRanges.push({
-                            start: missingRange.start,
-                            end: s,
-                        });
-                    }
-                    if (missingRange.end > e) {
-                        missingRanges.push({
-                            start: e,
-                            end: missingRange.end,
-                        });
-                    }
                 }
                 if (missingRanges.length === 0) break;
             }
             if (missingRanges.length === 0) {
                 if (!hashesSameAsTarget(group[0])) {
-                    console.warn(`Found a cohesive group that doesn't hash the same way we do. Expanding our range to be the full range of the group. This will be slower than it needs to.`);
+                    console.warn(`Could only match a cohesive group that doesn't hash the same way we do. Expanding our range to be the full range of the group. This will be slower than it needs to, and might cause issues that result in only partial synchronization. This should be fixable with a deploy.`, config.target);
                 }
                 return usedParts;
             }
@@ -418,9 +434,6 @@ export class PathRouter {
     public static getChildReadNodes(path: string, config?: {
         preferredNodeIds?: string[];
     }): {
-        // By default we hash the key directly under the path. However, If that is not how our nodes were sharded, as in they didn't use it as a prefix, then they will be sharded by hashing the full path, and so when we receive the data, we need to keep this in mind and filter the data based on the full path hash.
-        useFullPathHash?: boolean;
-
         // NOTE: If at all possible, we will cover all ranges. Node of the returned nodes will be redundant.
         //  - Sorted by range.start
         nodes: {
@@ -433,20 +446,66 @@ export class PathRouter {
         if (this.isSelfAuthority(path)) {
             return { nodes: [{ nodeId: getOwnNodeId(), range: { start: 0, end: 1 } }] };
         }
+        let preferredNodeIds = new Set(config?.preferredNodeIds ?? []);
 
         // If a prefix is a parent of path, then it is the same as matching just the path directly
         // (If our prefix directly equals one of the other matches, then it's more complicated, As then, the child keys of path are what is hashed, and so all the children will have different routes, so we might match multiple nodes. The same thing if we're matching the remaining case, in which case it's a full path hash, so the child key matters, and again, different routes).
         //      - The different route case is how the FuntionRunner works, and without it large databases couldn't run functions. However, most applications won't directly use it.
         let allSources = authorityLookup.getTopologySync();
-        allSources = allSources.filter(x => !isOwnNodeId(x.nodeId));
-        let nestedMatches = allSources.filter(x =>
-            x.authoritySpec.prefixes.some(y => path.startsWith(y) && y !== path)
-            && this.matchesAuthoritySpec(x.authoritySpec, path)
-        );
+        // Prefer our own node
+        sort(allSources, x => isOwnNodeId(x.nodeId) ? -1 : 1);
+
+
+        // Direct prefixes always take priority, as almost everything is under a prefix anyways...
+
+
+        // Direct prefix. This happens for things like calls and functions, it requires more advanced routing as it means we're going to route between multiple servers, but... it is important
+        let hasPrefix = allSources.filter(x => x.authoritySpec.prefixes.some(y => y === path)).map(x => x.authoritySpec);
+        if (hasPrefix.length > 0) {
+            shuffle(hasPrefix, Math.random());
+            sort(hasPrefix, x => preferredNodeIds.has(x.nodeId) ? -1 : 1);
+
+            let missingRanges: { start: number; end: number }[] = [{
+                start: 0,
+                end: 1,
+            }];
+            let usedParts: {
+                nodeId: string;
+                range: { start: number; end: number };
+            }[] = [];
+            for (let source of hasPrefix) {
+                let s = source.routeStart;
+                let e = source.routeEnd;
+                let { removedRanges } = removeRange(missingRanges, { start: s, end: e });
+                // NOTE: It's not ideal that we might have to fragment one node ID between multiple requests. However, in practice, there shouldn't be much fragmentation here. The ranges that our nodes are breaking down by should be consistent, so there's actually no overlap or subsets.
+                for (let removedRange of removedRanges) {
+                    usedParts.push({
+                        nodeId: source.nodeId,
+                        range: removedRange,
+                    });
+                }
+                if (missingRanges.length === 0) break;
+            }
+            if (missingRanges.length === 0) {
+                return { nodes: usedParts };
+            }
+        }
+
+        let nestedMatches = allSources.filter(x => {
+            // There's nested prefixes, so if we match any prefix explicitly, we can't just take one of the previous prefixes because that isn't how the hashing will work. 
+            // - This happens if it's a direct match, but one of the shards is down, in which case we can't get a full match.
+            if (x.authoritySpec.prefixes.some(y => y === path)) return false;
+
+            // If our path, which we're going to read the children of, is the child of another path, then it means in that other path, the child key will be known to us constant, and so we're going to match exactly one authority. 
+            return (
+                x.authoritySpec.prefixes.some(y => path.startsWith(y) && y !== path)
+                && this.matchesAuthoritySpec(x.authoritySpec, path)
+            );
+        });
         if (nestedMatches.length > 0) {
             shuffle(nestedMatches, Math.random());
-            let preferredNodeIds = new Set(config?.preferredNodeIds ?? []);
             sort(nestedMatches, x => preferredNodeIds.has(x.nodeId) ? -1 : 1);
+            sort(allSources, x => isOwnNodeId(x.nodeId) ? -1 : 1);
             return {
                 nodes: nestedMatches.map(x => ({
                     nodeId: x.nodeId,
@@ -456,25 +515,53 @@ export class PathRouter {
             };
         }
 
-        let fullSources = this.getAuthoritySources({
-            target: {
-                nodeId: "",
-                prefixes: [path],
-                routeStart: 0,
-                routeEnd: 1,
-                excludeDefault: true,
-            },
-            preferredNodeIds: config?.preferredNodeIds,
+        // If we are not under any prefixes of it, then it will be a full path hash
+        let fullPathMatches = allSources.filter(x => {
+            return !x.authoritySpec.prefixes.some(y => path.startsWith(y) && y !== path);
         });
-        if (fullSources.length === 0) return { nodes: [] };
+        // Same as prefix matches. Not preferred, and not preferred over being under a prefix, but required for some root data, or data with no prefixes.
+        if (fullPathMatches.length > 0) {
+            shuffle(fullPathMatches, Math.random());
+            sort(fullPathMatches, x => preferredNodeIds.has(x.nodeId) ? -1 : 1);
+            sort(allSources, x => isOwnNodeId(x.nodeId) ? -1 : 1);
+            let missingRanges: { start: number; end: number }[] = [{
+                start: 0,
+                end: 1,
+            }];
+            let usedParts: {
+                nodeId: string;
+                range: { start: number; end: number };
+            }[] = [];
+            for (let source of fullPathMatches) {
+                let s = source.authoritySpec.routeStart;
+                let e = source.authoritySpec.routeEnd;
+                let { removedRanges } = removeRange(missingRanges, { start: s, end: e });
+                // NOTE: It's not ideal that we might have to fragment one node ID between multiple requests. However, in practice, there shouldn't be much fragmentation here. The ranges that our nodes are breaking down by should be consistent, so there's actually no overlap or subsets.
+                for (let removedRange of removedRanges) {
+                    usedParts.push({
+                        nodeId: source.nodeId,
+                        range: removedRange,
+                    });
+                }
+                if (missingRanges.length === 0) break;
+            }
+            if (missingRanges.length === 0) {
+                return { nodes: usedParts };
+            }
+        }
 
-        return {
-            useFullPathHash: fullSources.some(x => x.useFullPathHash),
-            nodes: fullSources.map(x => ({
-                nodeId: x.nodeId,
-                range: { start: x.routeStart, end: x.routeEnd },
-            })),
-        };
+
+
+        // TODO: We could maybe match a partial match. However, even that is suspect. The site being partially broken is almost worse than it being completely broken. We should just get ALL the shards running again...
+
+
+        require("debugbreak")(2);
+        debugger;
+
+
+        // NOTE: We *could* actually synchronize it even if it doesn't have a prefix shard as we can fall back to just the full path sharding. However, it becomes very complicated if we want a specific range, and then it becomes complicated if it then switches to prefix hashing (With the nodes that were using the full path hashing slowly going away). AND... key synchronization IS slow, so it's good to discourage it in general. 
+        console.error(`Want to sync a prefix which is not under an existing prefix, nor equal to a prefix. 1) The servers are down. 2) Don't access the .keys() 3) call addRoutingPrefixForDeploy to add a route/parent route explicitly (as is done in PathFunctionRunner.ts). Path: ${JSON.stringify(path)}`, { path, allSources });
+        return { nodes: [] };
     }
 
 
@@ -538,3 +625,5 @@ export class PathRouter {
 
 }
 
+
+(globalThis as any).PathRouter = PathRouter;

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

@@ -22,7 +22,7 @@ let keySpecialIdentifier = (
 export function createRoutingOverrideKey(config: {
     originalKey: string;
     routeKey: string;
-    // This is not the prefix that it has to match. This is the prefix we remap it to. And so anything which matches this remap prefix will match this routing key. 
+    // This is the prefix it has the equivalent of. We need this, so if something excludes default, it doesn't automatically get every routing overridden value.
     remappedPrefix: string;
 }) {
     let { originalKey, routeKey, remappedPrefix } = config;

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

@@ -1,12 +1,12 @@
 import { SocketFunction } from "socket-function/SocketFunction";
 import { delay, batchFunction } from "socket-function/src/batching";
-import { isNode, timeInSecond } from "socket-function/src/misc";
+import { deepCloneJSON, isNode, timeInSecond } from "socket-function/src/misc";
 import { measureBlock, measureFnc } from "socket-function/src/profiling/measure";
 import { isTrustedByNode } from "../-d-trust/NetworkTrust2";
 import { areNodeIdsEqual, isOwnNodeId } from "../-f-node-discovery/NodeDiscovery";
 import { ActionsHistory } from "../diagnostics/ActionsHistory";
 import { errorToUndefined, logErrors, timeoutToUndefined } from "../errors";
-import { getPathFromStr } from "../path";
+import { getPathFromStr, hack_stripPackedPath } from "../path";
 import { PathValueControllerBase } from "./PathValueController";
 import { PathRouter } from "./PathRouter";
 import { PathValue, MAX_ACCEPTED_CHANGE_AGE, WriteState, debugPathValuePath, compareTime, epochTime } from "./pathValueCore";
@@ -16,6 +16,11 @@ import { red } from "socket-function/src/formatting/logColors";
 import { isClient } from "../config2";
 import { auditLog, isDebugLogEnabled } from "./auditLogs";
 import { authorityLookup } from "./AuthorityLookup";
+import { debugNodeId } from "../-c-identity/IdentityController";
+import { decodeNodeId } from "../-a-auth/certs";
+import { decodeParentFilter, encodeParentFilter } from "./hackedPackedPathParentFiltering";
+import { deepCloneCborx } from "../misc/cloneHelpers";
+import { removeRange } from "../rangeMath";
 setImmediate(() => import("../1-path-client/RemoteWatcher"));
 setImmediate(() => import("../4-querysub/Querysub"));
 
@@ -32,10 +37,7 @@ export type BatchValues = {
 export type RemoteValueAndValidState = {
     sourceNodeId: string;
     pathValues: PathValue[];
-    validStates: WriteState[];
     initialTriggers: { values: Set<string>; parentPaths: Set<string> };
-    // Means it's from an authority path sync
-    authoritySyncPaths?: Set<string>;
 };
 
 class PathValueCommitter {
@@ -194,7 +196,6 @@ class PathValueCommitter {
                         parentSyncs: [],
                         initialTriggers: { values: new Set(), parentPaths: new Set() },
                     });
-                    PathRouter.getAllAuthorities(pathValue.path);
                     console.error(`There are no authorities for path ${pathValue.path}. The write will be lost.`, {
                         path: pathValue.path,
                         timeId: pathValue.time.time,
@@ -215,6 +216,7 @@ class PathValueCommitter {
             // Don't send to bad nodes for 60 seconds
             const nodeIgnoreTime = Date.now() - 1000 * 60;
             let promises = Array.from(valuesPerOtherAuthority.entries()).map(async ([otherAuthority, values]) => {
+
                 let disconnected = SocketFunction.getLastDisconnectTime(otherAuthority);
                 if (disconnected && disconnected > nodeIgnoreTime) {
                     // If it disconnected recently... don't send to it for a little bit, so we don't spend
@@ -299,16 +301,34 @@ class PathValueCommitter {
             if (!isClient()) {
                 measureBlock(function ignoreUnrequestedValues() {
                     for (let batch of batched) {
-                        function isWrongAuthority(path: string) {
+                        function isWrongAuthority(path: string, value?: PathValue, type?: string) {
                             let watchingAuthorityId = remoteWatcher.getExistingWatchRemoteNodeId(path);
                             // If we AREN'T watching it... it's actually fine, we can receive any values.
                             //  When we start watching, those values will get clobbered.
                             if (watchingAuthorityId === undefined) return false;
-                            return !areNodeIdsEqual(watchingAuthorityId, batch.sourceNodeId);
+                            if (!areNodeIdsEqual(watchingAuthorityId, batch.sourceNodeId)) {
+                                let valueWatchNode = remoteWatcher.getValueWatchRemoteNodeId(path);
+                                if (!valueWatchNode || !areNodeIdsEqual(valueWatchNode, batch.sourceNodeId)) {
+                                    let candidates = PathRouter.getAllAuthorities(path);
+                                    require("debugbreak")(2);
+                                    debugger;
+                                    console.warn(`Ignoring value from wrong authority. Should have been ${debugNodeId(watchingAuthorityId)}, but was received from ${debugNodeId(batch.sourceNodeId)}.`, {
+                                        path,
+                                        type,
+                                        timeId: value?.time.time,
+                                        source: value?.source,
+                                        sourceNodeId: debugNodeId(batch.sourceNodeId),
+                                        sourceNodeThreadId: decodeNodeId(batch.sourceNodeId)?.threadId,
+                                        watchingAuthorityId: debugNodeId(watchingAuthorityId),
+                                        watchingAuthorityNodeThreadId: decodeNodeId(watchingAuthorityId)?.threadId,
+                                        isTransparent: value?.isTransparent,
+                                    });
+                                }
+                                return true;
+                            }
+                            return false;
                         }
                         batch.pathValues = batch.pathValues.filter(value => {
-                            // Authorities watch other authorities using path watches, And so one path can come from many authorities, so we just have to accept it no matter what, if it's from that type of source. 
-                            if (batch.authoritySyncPaths?.has(value.path)) return true;
                             // NOTE: See the definition for lock count for why this check isn't checking all the possible cases. Essentially, locks is often empty, and that's intentional. However, the reverse should never be true, locks should never have values when lockCount is 0. 
                             if (value.lockCount === 0 && value.locks.length > 0) {
                                 console.error(red(`Ignoring value with invalid lockCount. Was ${value.lockCount}, but we have ${value.locks.length} locks. locks are optional, but lockCount isn't. We should never have locks without having lockCount set. ${debugPathValuePath(value)}`));
@@ -316,30 +336,33 @@ class PathValueCommitter {
                             }
 
                             if (PathRouter.isSelfAuthority(value.path)) return true;
-                            if (isWrongAuthority(value.path)) return false;
-                            // epochTimes are just indicators that the value has no value, and so are safe to sync
-                            //  from any source. They won't cause future conflicts, because any other value overrides them.
-                            //  - This might not be required?
-                            if (compareTime(value.time, epochTime) === 0) {
-                                return true;
+                            if (isWrongAuthority(value.path, value, "value")) {
+                                return false;
                             }
-
-                            // Also warn, because... if we get a lot of these, there might be a bug.
-                            //  A few when we change watches is possible, but it should be rare.
-                            let watchingAuthorityId = remoteWatcher.getExistingWatchRemoteNodeId(value.path);
-                            auditLog("IGNORING VALUE FROM DIFFERENT AUTHORITY", { path: value.path, watchingAuthorityId, receivedFromAuthority: batch.sourceNodeId });
-                            return false;
+                            return true;
                         });
 
-                        for (let value of batch.initialTriggers.values) {
-                            if (isWrongAuthority(value)) {
+                        for (let value of Array.from(batch.initialTriggers.values)) {
+                            if (isWrongAuthority(value, undefined, "initialTrigger")) {
                                 batch.initialTriggers.values.delete(value);
                             }
                         }
-                        for (let parentPath of batch.initialTriggers.parentPaths) {
-                            if (isWrongAuthority(parentPath)) {
-                                batch.initialTriggers.parentPaths.delete(parentPath);
+                        for (let parentPath of Array.from(batch.initialTriggers.parentPaths)) {
+                            if (remoteWatcher.isFinalRemoteWatchPath({ parentPath, nodeId: batch.sourceNodeId })) {
+                                continue;
                             }
+
+                            // TODO: Remove this breakpoint eventually. This can happen naturally when servers go down?
+                            require("debugbreak")(2);
+                            debugger;
+                            remoteWatcher.isFinalRemoteWatchPath({ parentPath, nodeId: batch.sourceNodeId });
+
+                            console.warn(`Ignoring parent path which we aren't watching. From ${debugNodeId(batch.sourceNodeId)}.`, {
+                                parentPath,
+                                sourceNodeId: debugNodeId(batch.sourceNodeId),
+                                sourceNodeThreadId: decodeNodeId(batch.sourceNodeId)?.threadId,
+                            });
+                            batch.initialTriggers.parentPaths.delete(parentPath);
                         }
                     }
                 });
@@ -347,7 +370,7 @@ class PathValueCommitter {
 
 
             // path => sourceNodeId
-            let parentSyncs = new Map<string, string>();
+            let parentSyncs = new Map<string, Set<string>>();
 
             // We need to do a bit of work to properly clear path values that are from old initial triggers. As if we receive two initial triggers, they need to clobber each other. And if we collapse it, we lose that information. So we have to do that here. 
             let finalResults = new Map<string, {
@@ -380,16 +403,28 @@ class PathValueCommitter {
                     results.pathValues.push(pathValue);
                 }
                 for (let parentPath of batch.initialTriggers.parentPaths) {
-                    parentSyncs.set(parentPath, batch.sourceNodeId);
+                    let sourceNodeIds = parentSyncs.get(parentPath);
+                    if (!sourceNodeIds) {
+                        sourceNodeIds = new Set();
+                        parentSyncs.set(parentPath, sourceNodeIds);
+                    }
+                    sourceNodeIds.add(batch.sourceNodeId);
                 }
             }
 
             let parentPaths = new Set(parentSyncs.keys());
             let initialValues = new Set(Array.from(finalResults.values()).filter(x => x.initialTrigger).map(x => x.path));
 
+            let parentSyncsList: { parentPath: string; sourceNodeId: string }[] = [];
+            for (let [parentPath, sourceNodeIds] of parentSyncs.entries()) {
+                for (let sourceNodeId of sourceNodeIds) {
+                    parentSyncsList.push({ parentPath, sourceNodeId });
+                }
+            }
+
             validStateComputer.ingestValuesAndValidStates({
                 pathValues: Array.from(finalResults.values()).map(x => x.pathValues).flat(),
-                parentSyncs: Array.from(parentSyncs.entries()).map(([parentPath, sourceNodeId]) => ({ parentPath, sourceNodeId })),
+                parentSyncs: parentSyncsList,
                 initialTriggers: { values: initialValues, parentPaths: parentPaths },
             });
         },

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

@@ -159,13 +159,11 @@ export class PathValueControllerBase {
         }
 
         try {
-            let parentSyncs = Array.from(config.initialTriggers?.parentPaths || [])
-                .map(x => ({ parentPath: x, sourceNodeId: callerId }));
             let initialTriggers = config.initialTriggers || { values: new Set(), parentPaths: new Set() };
-            validStateComputer.ingestValuesAndValidStates({
+            await pathValueCommitter.ingestRemoteValuesAndValidStates({
                 pathValues: values,
-                parentSyncs,
                 initialTriggers,
+                sourceNodeId: callerId,
             });
         } catch (error) {
             console.error("Error ingesting values and valid states", error);