querysub 0.406.0 → 0.408.0

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 {
@@ -175,6 +177,7 @@ class PathValueCommitter {
                     auditLog("CREATE VALUE", {
                         path: pathValue.path,
                         timeId: pathValue.time.time,
+                        timeIdFull: pathValue.time,
                         source: pathValue.source,
                         transparent: pathValue.isTransparent,
                         // value: valueStr,
@@ -194,7 +197,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 +217,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
@@ -240,7 +243,7 @@ class PathValueCommitter {
                 void forwardPromise.then(x => {
                     if (x === "refused") {
                         values = values.map(value => {
-                            console.info(`Rejecting past value due to initial sync: ${debugPathValuePath(value)}`, {
+                            console.info(`Rejecting value that was refused: ${debugPathValuePath(value)}`, {
                                 path: value.path,
                                 timeId: value.time.time,
                             });
@@ -299,16 +302,35 @@ 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;
+                                    remoteWatcher.getExistingWatchRemoteNodeId(path);
+                                    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 +338,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 +372,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 +405,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

@@ -7,7 +7,6 @@ import { ActionsHistory } from "../diagnostics/ActionsHistory";
 import { isNode, nextId, timeInSecond, timeoutToUndefined } from "socket-function/src/misc";
 import { pathValueSerializer } from "../-h-path-value-serialize/PathValueSerializer";
 import { pathValueCommitter } from "./PathValueCommitter";
-import { Benchmark } from "../diagnostics/benchmark";
 import { auditLog, isDebugLogEnabled } from "./auditLogs";
 import { debugNodeId, debugNodeThread } from "../-c-identity/IdentityController";
 import { isDiskAudit } from "../config";
@@ -17,8 +16,18 @@ import { getNodeIdIP } from "socket-function/src/nodeCache";
 import { authorityLookup } from "./AuthorityLookup";
 import { timeoutToError } from "../errors";
 import { AuthoritySpec, PathRouter } from "./PathRouter";
+import { LZ4 } from "../storage/LZ4";
+import { Time } from "./pathValueCore";
+import { encodeCborx, decodeCborx } from "../misc/cloneHelpers";
+import { debugGetAllCallFactories } from "socket-function/src/nodeCache";
 export { pathValueCommitter };
 
+// ONLY returns non-canGCValues that are valid
+export type AuditSnapshotEntry = {
+    path: string;
+    time: Time;
+};
+
 // The sync test page has some functions which related to PathValueController significantly, and should always be exposed if PathValueController is exposed.
 if (isNode()) {
     setImmediate(() => {
@@ -43,6 +52,7 @@ export class PathValueControllerBase {
                 auditLog("SEND CREATED VALUE", {
                     path: value.path,
                     timeId: value.time.time,
+                    timeIdVersion: value.time.version,
                     targetNodeThreadId: debugNodeThread(nodeId),
                     transparent: value.isTransparent,
                     source: value.source,
@@ -66,6 +76,7 @@ export class PathValueControllerBase {
                 auditLog("SEND VALUE", {
                     path: pathValue.path,
                     timeId: pathValue.time.time,
+                    timeIdVersion: pathValue.time.version,
                     watcher: nodeId,
                     isValid: pathValue.valid,
                     nodeId: debugNodeId(nodeId),
@@ -119,7 +130,6 @@ export class PathValueControllerBase {
         let values: PathValue[] = [];
         if (valueBuffers) {
             values = await pathValueSerializer.deserialize(valueBuffers);
-            Benchmark.onReceivedValues(values);
             ActionsHistory.OnRead(values);
         }
 
@@ -152,6 +162,7 @@ export class PathValueControllerBase {
                     path: value.path,
                     // NOTE: Yes, this might conflict as we're throwing away a lot of information, however in practice no, it's not going to conflict when we're debugging, and this + path will be globally unique for every value we investigate.
                     timeId: value.time.time,
+                    timeIdVersion: value.time.version,
                     sourceNodeId,
                     sourceNodeThreadId: decodeNodeId(sourceNodeId)?.threadId,
                 });
@@ -159,13 +170,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);
@@ -254,6 +263,65 @@ export class PathValueControllerBase {
         });
         return buffers;
     }
+
+    public static async getAuditSnapshot(config: {
+        nodeId: string;
+        spec: AuthoritySpec;
+    }): Promise<AuditSnapshotEntry[]> {
+        let compressed = await PathValueController.nodes[config.nodeId].getAuditSnapshot(config);
+        let decompressed = LZ4.decompress(compressed);
+        return decodeCborx(decompressed);
+    }
+
+    public async getAuditSnapshot(config: {
+        spec: AuthoritySpec;
+    }): Promise<Buffer> {
+        let { spec } = config;
+        let { compareTime } = await import("./pathValueCore");
+
+        let allValues = authorityStorage.getAllValues({ spec, startTime: 0, endTime: Number.MAX_SAFE_INTEGER });
+
+        let pathToLatest = new Map<string, Time>();
+        for (let value of allValues) {
+            if (!value.valid) continue;
+            if (value.canGCValue) continue;
+
+            let existing = pathToLatest.get(value.path);
+            if (!existing || compareTime(value.time, existing) > 0) {
+                pathToLatest.set(value.path, value.time);
+            }
+        }
+
+        let entries: AuditSnapshotEntry[] = Array.from(pathToLatest.entries()).map(([path, time]) => ({ path, time }));
+
+        let encoded = encodeCborx(entries);
+        return LZ4.compress(encoded);
+    }
+
+
+    public static async getValuesByPathAndTime(config: {
+        nodeId: string;
+        entries: AuditSnapshotEntry[];
+    }): Promise<PathValue[]> {
+        let buffers = await PathValueController.nodes[config.nodeId].getValuesByPathAndTime(config.entries);
+        return await pathValueSerializer.deserialize(buffers);
+    }
+
+    public async getValuesByPathAndTime(entries: AuditSnapshotEntry[]): Promise<Buffer[]> {
+        let values: PathValue[] = [];
+        for (let entry of entries) {
+            let value = authorityStorage.getValueExactIgnoreInvalid(entry.path, entry.time);
+            if (!value) continue;
+            if (value.isTransparent) continue;
+            if (value.canGCValue) continue;
+            values.push(value);
+        }
+        let buffers = await pathValueSerializer.serialize(values, {
+            noLocks: true,
+            compress: getCompressNetwork(),
+        });
+        return buffers;
+    }
 }
 
 export const PathValueController = SocketFunction.register(
@@ -263,6 +331,8 @@ export const PathValueController = SocketFunction.register(
         sendData: {},
 
         getInitialValues: {},
+        getAuditSnapshot: {},
+        getValuesByPathAndTime: {},
 
         watchLatest: {},
         unwatchLatest: {},
@@ -273,5 +343,4 @@ export const PathValueController = SocketFunction.register(
     {
         noFunctionMeasure: !isNode(),
     }
-);
-
+);

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

@@ -11,14 +11,44 @@ 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 { matchesParentRangeFilter } from "./hackedPackedPathParentFiltering";
+import { isClient } from "../config2";
+import { delay } from "socket-function/src/batching";
 
+setImmediate(() => import("../4-querysub/Querysub"));
 
 // These are used so we can have our internal trigger lookup without watching them on remote values. 
 export function getInternalValueWatchPrefix() {
     return "INTERNAL_VALUE_WATCH_PREFIX_";
 }
 
+let pathWatcherState: (() => { watcherSequence: number }) | undefined;
+
+setImmediate(async () => {
+    const { createLocalSchema } = await import("../4-querysub/schemaHelpers");
+    const { t } = await import("../2-proxy/schema2");
+    pathWatcherState = createLocalSchema("pathWatcherState", {
+        watcherSequence: t.number
+    });
+});
+
+let triggering = false;
+function incrementWatcherSequence() {
+    if (!isClient()) return;
+    if (!pathWatcherState) return;
+    if (triggering) return;
+    triggering = true;
+    void delay(10).finally(async () => {
+        let { Querysub } = await import("../4-querysub/Querysub");
+        triggering = false;
+        Querysub.commit(() => {
+            if (!pathWatcherState) return;
+            let state = pathWatcherState();
+            state.watcherSequence = (state.watcherSequence || 0) + 1;
+        });
+    });
+}
+
 // WATCH CASES
 // 1) getOwnNodeId() is used to trigger pathValueClientWatcher (no one else should be using it)
 // 2) Use other nodes to immediately proxy to the other nodes
@@ -133,6 +163,7 @@ class PathWatcher {
         }
 
         if (newPathsWatched.size > 0 || newParentsWatched.size > 0) {
+            incrementWatcherSequence();
             if (isOwnNodeId(config.nodeId)) {
                 for (let path of newPathsWatched) {
                     auditLog("new local WATCH VALUE", { path });
@@ -177,6 +208,7 @@ class PathWatcher {
 
         if (!config.noInitialTrigger) {
             this.triggerValuesChanged({
+                onlyTriggerNodeId: config.nodeId,
                 valuesChanged: new Set(),
                 initialTriggers: { values: newPathsWatched, parentPaths: newParentsWatched },
             });
@@ -215,7 +247,6 @@ class PathWatcher {
 
             if (obj.watchers.size === 0) {
                 watchersObj.delete(path);
-                this.parentWatchers.delete(path);
                 fullyUnwatched.parentPaths.push(path);
                 authorityStorage.markParentPathAsUnwatched(path);
 
@@ -269,6 +300,7 @@ class PathWatcher {
         }
 
         if (fullyUnwatched.paths.length > 0 || fullyUnwatched.parentPaths.length > 0) {
+            incrementWatcherSequence();
             console.info(`Unwatched PathValue watches`, {
                 unwatchedPaths: fullyUnwatched.paths.length,
                 unwatchedParents: fullyUnwatched.parentPaths.length,
@@ -312,7 +344,7 @@ class PathWatcher {
         // ALSO, These path values need to be ingested first.
         valuesChanged: Set<PathValue>;
 
-        // We mutate initialTriggers
+        // Mutates initialTriggers.values
         initialTriggers: { values: Set<string>; parentPaths: Set<string> };
 
         onlyTriggerNodeId?: string;
@@ -339,14 +371,16 @@ class PathWatcher {
         for (let parentPath of initialTriggers.parentPaths) {
             let valuePaths = authorityStorage.getPathsFromParent(parentPath);
             for (let valuePath of valuePaths || []) {
+                // IMPORTANT! Add all the values to the initial triggers so then later we not only trigger them but know their initial trigger so we can make sure that the is initial trigger logic for each value runs as well. 
+                initialTriggers.values.add(valuePath);
                 triggerPaths.add(valuePath);
-                config.initialTriggers.values.add(valuePath);
             }
 
             let latestParentWatches = this.parentWatchers.get(hack_stripPackedPath(parentPath));
             if (!latestParentWatches) continue;
             for (let { watchers } of latestParentWatches.values()) {
                 for (let watcher of watchers) {
+                    if (onlyTriggerNodeId && watcher !== onlyTriggerNodeId) continue;
                     let changes = changedPerCallbacks.get(watcher);
                     if (!changes) {
                         changes = { values: new Set(), initialTriggers: { values: new Set(), parentPaths: new Set() } };
@@ -383,6 +417,7 @@ class PathWatcher {
                     changes.values.add(value);
                 }
                 if (isInitialTrigger) {
+                    changes.initialTriggers.values.add(path);
                     let watcherObj = this.watchersToPaths.get(watcher);
                     let fullHistory = watcherObj?.fullHistory;
                     if (fullHistory) {
@@ -502,6 +537,13 @@ class PathWatcher {
         return Array.from(this.parentWatchers.keys());
     }
 
+    public getAllWatchedPaths(): string[] {
+        if (pathWatcherState) {
+            pathWatcherState().watcherSequence;
+        }
+        return Array.from(this.watchers.keys());
+    }
+
     public debug_harvestSyncTimes(): { start: number; end: number; path: string; }[] {
         let times = this.syncHistoryForHarvest.getAllUnordered();
         this.syncHistoryForHarvest.reset();

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

@@ -9,6 +9,7 @@
     After a PathServerValue starts, it can't change its prefixes, as if the routing changes it makes it too difficult for clients to reason about who they should be synchronizing with.
 */
 
+import { isNode } from "typesafecss";
 import { nestArchives } from "../-a-archives/archives";
 import { getArchivesBackblaze } from "../-a-archives/archivesBackBlaze";
 import { archiveJSONT } from "../-a-archives/archivesJSONT";
@@ -23,9 +24,14 @@ let prefixes = archiveJSONT<PrefixObj>(() => nestArchives("shard-prefixes/", get
 const key = "all";
 
 export async function getShardPrefixes(): Promise<string[]> {
+    if (!isNode()) return [];
     return (await prefixes.get(key))?.prefixes ?? [];
 }
 
 export async function setShardPrefixes(_prefixes: string[]) {
+    console.log("Setting shard prefixes");
+    for (let prefix of _prefixes) {
+        console.log("Prefix:", prefix);
+    }
     await prefixes.set(key, { prefixes: _prefixes });
 }

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

@@ -5,7 +5,7 @@ import { isDiskAudit } from "../config";
 import { getPathFromStr } from "../path";
 import { auditLog } from "./auditLogs";
 import { PathRouter } from "./PathRouter";
-import { PathValue, authorityStorage, compareTime, debugPathValuePath, ReadLock, byLockGroup, isCoreQuiet, debugRejections, debugTime, debugPathValue } from "./pathValueCore";
+import { PathValue, authorityStorage, compareTime, debugPathValuePath, ReadLock, byLockGroup, isCoreQuiet, debugRejections, debugTime, debugPathValue, MAX_CHANGE_AGE } from "./pathValueCore";
 import { pathWatcher } from "./PathWatcher";
 import { lockWatcher2 } from "./LockWatcher2";
 import { onPathInteracted } from "../diagnostics/pathAuditerCallback";
@@ -82,7 +82,9 @@ class ValidStateComputer {
                         console.info(`Rejecting past value due to initial sync: ${debugPathValuePath(value)}`, {
                             path: value.path,
                             timeId: value.time.time,
+                            timeIdFull: value.time,
                             newTimeId: newValue?.time.time,
+                            newTimeIdFull: newValue?.time,
                         });
                         ourValues.push({ ...value, valid: false, });
                     }
@@ -158,10 +160,11 @@ class ValidStateComputer {
         }
         return !!value.valid;
     }
-    private isLockContentionFree(lock: ReadLock): PathValue | undefined {
+    private isLockContentionFree(lock: ReadLock): PathValue[] | undefined {
         // sorted by -time (newest are first)
         let history = authorityStorage.getValuePlusHistory(lock.path);
 
+        let conflictingValues: PathValue[] | undefined;
         let index = binarySearchIndex(history.length, i => compareTime(lock.endTime, history[i].time));
         if (index < 0) index = ~index;
         else index++;
@@ -172,10 +175,11 @@ class ValidStateComputer {
             if (value.isTransparent && lock.readIsTransparent) continue;
             // If value.time is within our range, there's contention!
             if (compareTime(lock.startTime, value.time) < 0 && compareTime(value.time, lock.endTime) < 0) {
-                return value;
+                if (!conflictingValues) conflictingValues = [];
+                conflictingValues.push(value);
             }
         }
-        return undefined;
+        return conflictingValues;
     }
 
     @measureFnc
@@ -193,6 +197,10 @@ class ValidStateComputer {
 
             let valid = true;
             for (let lock of locks) {
+                let age = now - lock.endTime.time;
+                // If it's old enough, then it's always valid, we can't change the valid save something after its max change age, even if it's invalid. 
+                if (age > MAX_CHANGE_AGE) continue;
+
                 if (!this.isLockValid(lock)) {
                     onPathInteracted(lock.path, 2);
                     valid = false;
@@ -259,7 +267,7 @@ class ValidStateComputer {
             }
         }
     }
-    private logLockContention(valueGroup: PathValue[], lock: ReadLock, conflictingValue: PathValue, now: number) {
+    private logLockContention(valueGroup: PathValue[], lock: ReadLock, conflictingValues: PathValue[], now: number) {
 
         // This special version indicates clientside prediction (which SHOULD be rejected).
         if (lock.endTime.version !== Number.MAX_SAFE_INTEGER) {
@@ -278,7 +286,7 @@ class ValidStateComputer {
                     redMessage += `\n    (original read from: ${debugTime(lock.startTime)}`;
                     redMessage += `\n    (at time: ${debugTime(lock.endTime)}`;
                     redMessage += `\n    (current time: ${Date.now()})`;
-                    redMessage += `\n    (conflict write at: ${debugTime(conflictingValue.time)}`;
+                    redMessage += `\n    (conflict write at: ${debugTime(conflictingValues[0].time)}`;
                     console.error(redMessage);
                 }
                 if (isDiskAudit()) {
@@ -287,11 +295,15 @@ class ValidStateComputer {
                             lock,
                             path: pathValue.path,
                             timeId: pathValue.time.time,
+                            timeIdVersion: pathValue.time.version,
+                            timeIdFull: pathValue.time,
                             lockedPath: lock.path,
                             transparent: lock.readIsTransparent,
                             missingPath: lock.path,
-                            conflictTimeId0: conflictingValue.time.time,
-                            conflictingWrites: conflictingValue,
+                            conflictTimeId0: conflictingValues[0].time.time,
+                            conflictTimeIdVersion0: conflictingValues[0].time.version,
+                            conflictCount: conflictingValues.length,
+                            conflictingWrites: conflictingValues,
                             hadTimeId: lock.startTime.time,
                         });
                     }