querysub 0.461.0 → 0.463.0

package/src/2-proxy/archiveMoveHarness.ts

@@ -3,7 +3,7 @@ import { blue, green, red } from "socket-function/src/formatting/logColors";
 import { measureBlock, measureWrap } from "socket-function/src/profiling/measure";
 import { FileInfo, ArchiveTransaction } from "../0-path-value-core/archiveLocks/ArchiveLocks";
 import { DecodedValuePath, pathValueArchives, PathValueArchives } from "../0-path-value-core/pathValueArchives";
-import { PathValue, VALUE_GC_THRESHOLD, FILE_VALUE_COUNT_LIMIT, FILE_SIZE_LIMIT, compareTime } from "../0-path-value-core/pathValueCore";
+import { PathValue, FILE_VALUE_COUNT_LIMIT, FILE_SIZE_LIMIT, compareTime, ARCHIVE_STABLE_THRESHOLD } from "../0-path-value-core/pathValueCore";
 import { getSingleSizeEstimate } from "../5-diagnostics/shared";
 import { logNodeStats } from "../-0-hooks/hooks";
 import debugbreak from "debugbreak";
@@ -67,7 +67,7 @@ export async function runArchiveMover(config: {
     }>;
 }) {
     let authority = config.authority ?? await getOurAuthoritySpec(true);
-    let minAge = config.readLiveData ? Number.NEGATIVE_INFINITY : VALUE_GC_THRESHOLD;
+    let minAge = config.readLiveData ? Number.NEGATIVE_INFINITY : ARCHIVE_STABLE_THRESHOLD;
     let minThreshold = Date.now() - minAge;
     // NOTE: If the value count is too high, parsing in the ArchiveViewer might crash the browser.
     const maxFileValueCount = config.maxFileValueCount ?? FILE_VALUE_COUNT_LIMIT;

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

@@ -9,7 +9,7 @@ import { getPathFromStr, getPathIndex } from "../path";
 import { rawSchema } from "../2-proxy/pathDatabaseProxyBase";
 import { getProxyPath } from "../2-proxy/pathValueProxy";
 import { atomicObjectRead, atomicObjectWrite, doProxyOptions, isProxyBlockedByOrder, isSynced, proxyWatcher } from "../2-proxy/PathValueProxyWatcher";
-import { authorityStorage, compareTime, debugTime, MAX_ACCEPTED_CHANGE_AGE, parseDebugTime, PathValue, Time } from "../0-path-value-core/pathValueCore";
+import { authorityStorage, compareTime, debugTime, epochTime, MAX_ACCEPTED_CHANGE_AGE, parseDebugTime, PathValue, Time } from "../0-path-value-core/pathValueCore";
 import { getModuleFromSpec } from "./pathFunctionLoader";
 import debugbreak from "debugbreak";
 import { parseArgs } from "./PathFunctionHelpers";
@@ -163,6 +163,10 @@ function getDebugName(call: CallSpec, functionSpec: FunctionSpec | undefined, co
     }
     let pathName = getPathFromStr(functionSpec.exportPathStr).slice(1).join(".");
     let mainPart = `${call.DomainName}:${functionSpec.FilePath}|${pathName}|${debugTime(call.runAtTime)}`;
+    let caller = proxyWatcher.getTriggeredWatcherMaybeUndefined();
+    if (caller && caller.nextWriteTime) {
+        mainPart += ` (@ ${debugTime(caller.nextWriteTime)})`;
+    }
     if (colored) {
         return `${magenta(mainPart)}`;
     } else {
@@ -355,7 +359,10 @@ export class PathFunctionRunner {
                         //  but the result is by definition not, so... it is one of the values we check!
                         if (!isSynced(moduleData.Results[callId])) continue;
 
-                        if (runningCalls.has(callId)) continue;
+                        if (runningCalls.has(callId)) {
+                            console.log(`Skipping run of already running call ${callId} at ${debugTime(callData.runAtTime)}`);
+                            continue;
+                        }
                         runningCalls.add(callId);
 
                         let limitCount = queueLimitCounts.get(callId) || 0;
@@ -460,7 +467,7 @@ export class PathFunctionRunner {
         let fraction = getRoutingOverridePart(callPath.CallId)?.route;
         if (fraction === undefined) {
             fraction = PathRouter.getSingleKeyRoute(callPath.CallId);
-            console.error(`No routing override found for callId, falling back to direct hash`, { callId: callPath.CallId, fraction, domainName: callPath.DomainName, moduleId: callPath.ModuleId, functionId: callPath.FunctionId, callerMachineId: callPath.callerMachineId, callerIP: callPath.callerIP });
+            console.error(`No routing override found for callId (missing keyOverride fnc for ${callPath.ModuleId}.${callPath.FunctionId}), falling back to direct hash (this WILL cause rejections if this function is called a lot, ADD a keyOverride function in the definition)`, { callId: callPath.CallId, fraction, domainName: callPath.DomainName, moduleId: callPath.ModuleId, functionId: callPath.FunctionId, callerMachineId: callPath.callerMachineId, callerIP: callPath.callerIP });
         }
         // It isn't secondary if it is primary
         if (shardRange.startFraction <= fraction && fraction < shardRange.endFraction) return 0;
@@ -479,23 +486,21 @@ export class PathFunctionRunner {
         );
     };
 
-    private callsRemainingInTick = cache((wait: true) => {
-        // NOTE: This gives us 100K calls per second, which is more than we can run anyways.
-        //  We just need to wait a bit, otherwise the IO loop can never run, and so our finished calls
-        //  can never actually finish, until eventually they are too late to finish and get rejected!
-        let tickDone = delay(10);
-        void tickDone.finally(() => {
-            this.callsRemainingInTick.clear(true);
-        });
-        return { calls: 1000, tickDone };
-    });
-    private async letIOClear(): Promise<void> {
-        while (true) {
-            let callsObj = this.callsRemainingInTick(true);
-            callsObj.calls--;
-            if (callsObj.calls >= 0) return;
-            await callsObj.tickDone;
+    private pendingTickWaiters: { runAtTime: Time; resolve: () => void; }[] | undefined;
+    private async letIOClear(runAtTime: Time): Promise<void> {
+        if (!this.pendingTickWaiters) {
+            let waiters: { runAtTime: Time; resolve: () => void; }[] = [];
+            this.pendingTickWaiters = waiters;
+            void delay(100).then(() => {
+                this.pendingTickWaiters = undefined;
+                waiters.sort((a, b) => compareTime(a.runAtTime, b.runAtTime));
+                for (let w of waiters) w.resolve();
+            });
         }
+        let waiters = this.pendingTickWaiters;
+        await new Promise<void>(resolve => {
+            waiters.push({ runAtTime, resolve });
+        });
     }
 
     private callStats = new Map<string, CallStats>();
@@ -558,7 +563,7 @@ export class PathFunctionRunner {
             gitRef: functionSpec.gitRef,
         });
 
-        await this.letIOClear();
+        await this.letIOClear(callSpec.runAtTime);
 
         let secondaryDelay = this.getSecondaryShardDelay(callSpec);
         if (secondaryDelay) {
@@ -589,7 +594,7 @@ export class PathFunctionRunner {
 
         PathFunctionRunner.RUN_START_COUNT++;
         if (PathFunctionRunner.DEBUG_CALLS) {
-            console.log(`STARTING ${debugNameColored}`);
+            console.log(`STARTING ${debugNameColored} at realtime ${Date.now()}`);
         }
         let startTime = Date.now();
         let runCount = 0;
@@ -644,6 +649,8 @@ export class PathFunctionRunner {
 
                 await proxyWatcher.commitFunction({
                     canWrite: true,
+                    // IMPORTANT! If we wait, it actually means that we could get the rejection before we finish the run call function. So the rejection will be suppressed because we'll think we'll still inside of a call. So that's bad. So we can't wait for the commit. 
+                    noWaitForCommit: true,
                     debugName: debugName,
                     source: debugName,
                     runAtTime: callSpec.runAtTime,
@@ -819,7 +826,7 @@ export class PathFunctionRunner {
         }
 
         if (PathFunctionRunner.DEBUG_CALLS) {
-            console.log(`FINISHED${nooped ? " (skipped)" : ""} ${debugNameColored}, writes: ${finalWrites?.length}, took ${blue(formatTime(Date.now() - startTime))}`);
+            console.log(`FINISHED${nooped ? " (skipped)" : ""} ${debugNameColored}, writes: ${finalWrites?.length}, took ${blue(formatTime(Date.now() - startTime))} ran at ${debugTime(finalWrites?.[0]?.time || epochTime)}`);
         }
 
         let wallTime = Date.now() - startTime;
@@ -873,6 +880,7 @@ export class PathFunctionRunner {
 
         await proxyWatcher.commitFunction({
             canWrite: true,
+            noWaitForCommit: true,
             // NOTE: We don't set runAtTime, because the rejection might be due to the call being too old
             debugName: `error (${getDebugName(callSpec, functionSpec)})`,
             eventWrite: true,

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

@@ -24,7 +24,7 @@ import { IndexedLogs } from "../diagnostics/logs/IndexedLogs/IndexedLogs";
 
 async function main() {
     const { PermissionsCheck } = await import("../4-querysub/permissions");
-    const { Querysub } = await import("../4-querysub/QuerysubController");
+    const { Querysub } = await import("../4-querysub/Querysub");
     Error.stackTraceLimit = 20;
 
     //ActionsHistory.LOG_ACTION_HISTORY = "runner";
@@ -34,8 +34,6 @@ async function main() {
     // ClientWatcher.DEBUG_TRIGGERS = "heavy";
     // authorityStorage.DEBUG_UNWATCH = true;
 
-    Querysub.SEND_FULL_HISTORY_ON_INITIAL_SYNC = true;
-
     PathFunctionRunner.DEBUG_CALLS = true;
     // debugCoreMode();
 

package/src/4-deploy/deployFunctions.ts

@@ -1,6 +1,6 @@
 import { magenta } from "socket-function/src/formatting/logColors";
 import { FunctionSpec, preloadFunctions } from "../3-path-functions/PathFunctionRunner";
-import { Querysub } from "../4-querysub/QuerysubController";
+import { Querysub } from "../4-querysub/Querysub";
 import { errorify, timeoutToError } from "../errors";
 import { runPromise } from "../functional/runCommand";
 import path from "path";

package/src/4-deploy/deployMain.ts

@@ -7,7 +7,7 @@ import { blue, red } from "socket-function/src/formatting/logColors";
 import { timeInHour } from "socket-function/src/misc";
 import { shutdown } from "../diagnostics/periodic";
 import { deployFunctions, deployGetFunctions } from "./deployFunctions";
-import { Querysub } from "../4-querysub/QuerysubController";
+import { Querysub } from "../4-querysub/Querysub";
 import { setShardPrefixes } from "../0-path-value-core/ShardPrefixes";
 
 let yargObj = yargs(process.argv)

package/src/4-deploy/edgeClientWatcher.tsx

@@ -1,5 +1,5 @@
 import { SocketFunction } from "socket-function/SocketFunction";
-import { Querysub } from "../4-querysub/QuerysubController";
+import { Querysub } from "../4-querysub/Querysub";
 import { deploySchema } from "./deploySchema";
 import { getDomain, noSyncing } from "../config";
 import { throttleFunction, timeInMinute, timeInSecond } from "socket-function/src/misc";

package/src/4-deploy/edgeNodes.ts

@@ -20,7 +20,7 @@ import { blue, magenta } from "socket-function/src/formatting/logColors";
 import { errorToUndefined } from "../errors";
 import { deploySchema } from "./deploySchema";
 import { atomic, proxyWatcher } from "../2-proxy/PathValueProxyWatcher";
-import { Querysub } from "../4-querysub/QuerysubController";
+import { Querysub } from "../4-querysub/Querysub";
 import { onEdgeNodesChanged } from "./edgeBootstrap";
 import { startEdgeNotifier } from "./edgeClientWatcher";
 import { getGitRefLive, getGitURLLive } from "./git";

package/src/4-dom/qreactTest.tsx

@@ -8,7 +8,7 @@ import { isDeploy } from "../4-deploy/deployCheck";
 import { logErrors } from "../errors";
 import { watchFilesAndTriggerHotReloading } from "socket-function/hot/HotReloadController";
 import { qreact } from "./qreact";
-import { Querysub } from "../4-querysub/QuerysubController";
+import { Querysub } from "../4-querysub/Querysub";
 import { PermissionsCheck } from "../4-querysub/permissions";
 import { delay } from "socket-function/src/batching";
 import { formatTime } from "socket-function/src/formatting/format";

package/src/4-querysub/Querysub.ts

@@ -18,7 +18,7 @@ import { RequireController, setRequireBootRequire } from "socket-function/requir
 import { cache, cacheLimited, lazy } from "socket-function/src/caching";
 import { getOwnMachineId, getOwnThreadId, getThreadKeyCert, verifyMachineIdForPublicKey } from "../-a-auth/certs";
 import { getHostedIP, getSNICerts, publishMachineARecords } from "../-e-certs/EdgeCertController";
-import { debugCoreMode, registerGetCompressNetwork, authorityStorage } from "../0-path-value-core/pathValueCore";
+import { debugCoreMode, registerGetCompressNetwork, authorityStorage, enableDebugRejections } from "../0-path-value-core/pathValueCore";
 import { clientWatcher, ClientWatcher } from "../1-path-client/pathValueClientWatcher";
 import { SyncWatcher, proxyWatcher, specialObjectWriteValue, isSynced, PathValueProxyWatcher, atomic, doAtomicWrites, noAtomicSchema, undeleteFromLookup, registerSchemaPrefix, WatcherOptions, doProxyOptions } from "../2-proxy/PathValueProxyWatcher";
 import { isInProxyDatabase, rawSchema } from "../2-proxy/pathDatabaseProxyBase";
@@ -26,7 +26,6 @@ import { isValueProxy2, getProxyPath } from "../2-proxy/pathValueProxy";
 import { getCurrentCallAllowUndefined, getCurrentCall, CallSpec, PathFunctionRunner } from "../3-path-functions/PathFunctionRunner";
 import { logErrors } from "../errors";
 import { getLastPathPart, getPathIndexAssert, getPathStr2 } from "../path";
-import { QuerysubController, anyPredictionsPending, flushDelayedFunctions, onCallPredict, waitUntilAllPredictionsFinish } from "./QuerysubController";
 import { PermissionsCheck } from "./permissions";
 import { inlineNestedCalls, syncSchema } from "../3-path-functions/syncSchema";
 import type { identityStorageKey, IdentityStorageType } from "../-a-auth/certs";
@@ -75,6 +74,7 @@ let yargObj = parseArgsFactory()
     .option("verboseframework", { type: "boolean", desc: "Log internal SocketFunction framework" })
     .option("nodelay", { type: "boolean", desc: "Don't delay committing functions, even ones that are marked to be delayed." })
     .option("hot", { type: "boolean", desc: "force hot reloading to turn on even if public is true." })
+    .option("ngc", { type: "boolean", desc: "Never GC values, useful for debugging." })
     .argv
     ;
 setImmediate(() => {
@@ -97,6 +97,8 @@ setImmediate(() => {
         ClientWatcher.DEBUG_READS = true;
         PathFunctionRunner.DEBUG_CALLS = true;
         Querysub.DEBUG_CALLS = true;
+        authorityStorage.DEBUG_UNWATCH = true;
+        enableDebugRejections();
     }
     if (yargObj.verbosenetwork) {
         SocketFunction.logMessages = true;
@@ -107,6 +109,9 @@ setImmediate(() => {
     if (yargObj.nodelay) {
         Querysub.DELAY_COMMIT_DELAY = 0;
     }
+    if (yargObj.ngc) {
+        authorityStorage.DEBUG_NEVER_GC = true;
+    }
 });
 
 if (!registerGetCompressNetwork) {
@@ -202,12 +207,6 @@ export class Querysub {
      */
     public static MAX_FUTURE_CALL_TIME = 10_000;
 
-    /** NOTE: Is required for the function runner to work. Eventually, we should allow you to request the full history on just specific paths.
-     *      - It's not *actually* the full history, As the underlying path value storage will delete values that are past the golden threshold anyways.
-     */
-    public static SEND_FULL_HISTORY_ON_INITIAL_SYNC = false;
-
-
     public static COMPRESS_NETWORK = true;
 
     public static now = getSyncedTime;
@@ -1361,4 +1360,4 @@ import { LOCAL_DOMAIN } from "../0-path-value-core/PathRouter";
 import { authorityLookup } from "../0-path-value-core/AuthorityLookup";
 import { encodeParentFilter } from "../0-path-value-core/hackedPackedPathParentFiltering";
 import { AliveChecker, registerAliveChecker } from "../2-proxy/garbageCollection";
-
+import { QuerysubController, anyPredictionsPending, flushDelayedFunctions, onCallPredict, waitUntilAllPredictionsFinish } from "./QuerysubController";

package/src/4-querysub/QuerysubController.ts

@@ -43,7 +43,6 @@ import { authorityLookup } from "../0-path-value-core/AuthorityLookup";
 import { PathValueArchives } from "../0-path-value-core/pathValueArchives";
 
 
-export { Querysub, id };
 
 
 // TODO: Eventually this will be split by domain, which required nodeIds to be split by domain, so that getControllerNodeId can check nodeIds on a specific domain.
@@ -684,12 +683,28 @@ export class QuerysubControllerBase {
         }
         return result;
     }
+    public async debugGetDetailedSyncing(): Promise<Map<string, number>> {
+        let callerId = SocketFunction.getCaller().nodeId;
+        let watchers = pathWatcher.debugGetWatcherPaths(callerId);
+        let result = new Map<string, { count: number }>();
+        for (let path of watchers?.paths ?? []) {
+            let nodeId = remoteWatcher.getValueWatchRemoteNodeId(path) ?? "UNKNOWN";
+            let obj = result.get(nodeId);
+            if (!obj) {
+                obj = { count: 0 };
+                result.set(nodeId, obj);
+            }
+            obj.count++;
+        }
+        return new Map(Array.from(result.entries()).map(([nodeId, obj]) => [nodeId, obj.count]));
+    }
 
     public async debugGetValuePathCount(): Promise<number> {
         return PathValueArchives.getValuePathCount();
     }
 }
 
+let lazyManagementPages = () => require("../diagnostics/managementPages") as typeof import("../diagnostics/managementPages");
 export const QuerysubController = SocketFunction.register(
     "QuerysubController-6db5ef05-7563-4473-a440-2f64f03fe6ef",
     new QuerysubControllerBase(),
@@ -701,6 +716,9 @@ export const QuerysubController = SocketFunction.register(
         // NOTE: Most of these debug functions are pretty innocuous. A lot of it is actually already exposed, and other parts of it is fine. It's fine for the user to know what node a path is on. It's fine for them to know how many value paths there are.
         debugGetPathNodeIds: {},
         debugGetNodeSpecs: {},
+        debugGetDetailedSyncing: {
+            hooks: [lazyManagementPages().assertIsManagementUser]
+        },
         debugGetSingleReadNode: {},
         getModulePath: {},
         getDevFunctionSpecFromCall: {},

package/src/4-querysub/permissions.ts

@@ -11,7 +11,7 @@ import { ignoreErrors } from "../errors";
 import { epochTime } from "../0-path-value-core/pathValueCore";
 import { isClient } from "../config2";
 import { sort } from "socket-function/src/misc";
-import { Querysub } from "./QuerysubController";
+import { Querysub } from "./Querysub";
 import { CALL_PERMISSIONS_KEY } from "./permissionsShared";
 import { getDomain, isLocal, isPublic } from "../config";
 

package/src/4-querysub/predictionQueue.tsx

@@ -3,7 +3,7 @@ import { CallSpec, debugCallSpec, functionSchema } from "../3-path-functions/Pat
 import { FunctionMetadata } from "../3-path-functions/syncSchema";
 import { getParentPathStr, getPathFromStr, getPathStr2 } from "../path";
 import { PromiseObj } from "../promise";
-import { Querysub } from "./QuerysubController";
+import { Querysub } from "./Querysub";
 import { PredictResult } from "./querysubPrediction";
 import { delay } from "socket-function/src/batching";
 import { blue, green, magenta, yellow } from "socket-function/src/formatting/logColors";

package/src/4-querysub/querysubPrediction.ts

@@ -1,5 +1,5 @@
 import { cacheJSONArgsEqual, lazy } from "socket-function/src/caching";
-import { MAX_CHANGE_AGE, PathValue, ReadLock, Time, authorityStorage, predictionLockVersion } from "../0-path-value-core/pathValueCore";
+import { DEFER_LOCK_WINDOW, MAX_CHANGE_AGE, PREDICT_HOLD_TIME, PathValue, ReadLock, Time, authorityStorage, predictionLockVersion } from "../0-path-value-core/pathValueCore";
 import { validStateComputer } from "../0-path-value-core/ValidStateComputer";
 import { proxyWatcher, atomicObjectRead, DryRunResult, getCurrentCallCreationProxy } from "../2-proxy/PathValueProxyWatcher";
 import { getProxyPath } from "../2-proxy/pathValueProxy";
@@ -7,7 +7,8 @@ import { CallSpec, FunctionResult, FunctionSpec, functionSchema, overrideCurrent
 import { getModuleFromConfig, setGitURLMapping } from "../3-path-functions/pathFunctionLoader";
 import { logErrors } from "../errors";
 import { getPathFromStr, getPathStr1 } from "../path";
-import { Querysub, QuerysubController, QuerysubControllerBase, registerPredictionBlocker, querysubNodeId } from "./QuerysubController";
+import { QuerysubController, QuerysubControllerBase, registerPredictionBlocker, querysubNodeId } from "./QuerysubController";
+import { Querysub } from "./Querysub";
 import { parseArgs } from "../3-path-functions/PathFunctionHelpers";
 import { magenta, red } from "socket-function/src/formatting/logColors";
 import { pathValueSerializer } from "../-h-path-value-serialize/PathValueSerializer";
@@ -24,12 +25,13 @@ import { delay } from "socket-function/src/batching";
 setFlag(require, "cbor-x", "allowclient", true);
 const cborEncoder = lazy(() => new cbor.Encoder({ structuredClone: true }));
 
-let onPredictionFinishedCallbacks: Array<(data: { callId: string; result: FunctionResult; functionId: string }) => void> = [];
+let onPredictionFinishedCallbacks: Array<(data: { callId: string; result: FunctionResult; functionId: string; creatorId: number }) => void> = [];
 
 export function onPredictionFinished(callback: (data: {
     callId: string;
     result: FunctionResult;
     functionId: string;
+    creatorId: number;
 }) => void) {
     onPredictionFinishedCallbacks.push(callback);
 }
@@ -127,14 +129,19 @@ function predictCallBase(config: {
     let actualValueFinished = new PromiseObj();
     function onActualFinished() {
         if (actualValueFinished.resolveCalled) return;
-        let resultObj = authorityStorage.getValueAtTime(pathResultWrite, undefined);
+        let resultObj = authorityStorage.getValueAtOrBeforeTime(pathResultWrite, undefined);
         let result = pathValueSerializer.getPathValue(resultObj) as FunctionResult | undefined;
         if (!result) return;
         if (result.lastInternalLoopCount === -1) return;
-        void cleanupPrediction();
+        // NOTE: Using resultObj.transactionPaths, It is possible, although a little bit annoying, for us to determine if it's likely we are missing transaction paths because we know the prediction paths and we know if we're watching those or not. And if we're watching them and they hash the same paths in the result write, and the times are before the result write, then we know we're missing data.
+        //  BUT... It doesn't matter because we could just wait here, and there's not really any downside to waiting here. 
+        setTimeout(() => {
+            void cleanupPrediction();
+        }, PREDICT_HOLD_TIME);
         actualValueFinished.resolve();
+        let creatorId = resultObj && resultObj.time.creatorId || 0;
         for (let callback of onPredictionFinishedCallbacks) {
-            callback({ callId: call.CallId, result, functionId: call.FunctionId });
+            callback({ callId: call.CallId, result, functionId: call.FunctionId, creatorId });
         }
     }
     function onApplied() {
@@ -224,7 +231,7 @@ function predictCallBase(config: {
             }
             dryRunResult = tempDryRunResult;
         } catch (e: any) {
-            if (!pathValueSerializer.getPathValue(authorityStorage.getValueAtTime(pathResultWrite, undefined))) {
+            if (!pathValueSerializer.getPathValue(authorityStorage.getValueAtOrBeforeTime(pathResultWrite, undefined))) {
                 console.log(`Skipping prediction for ${debugName} due to error running predictive call. Likely just an out of order error.`, e.stack);
             } else {
                 // NOTE: This case happens a lot, because of how we handle locks. We don't receive locked values, and so
@@ -246,9 +253,15 @@ function predictCallBase(config: {
             readParentPaths: dryRunResult.readParentPaths,
             replacedWriteValues: dryRunResult.writes.map(write => {
                 let path = write.path;
-                let newWrite: PathValue = authorityStorage.getValueAtTime(write.path, write.time) || {
-                    path, valid: true, time: write.time, locks: [], lockCount: 0, value: undefined, canGCValue: true, isTransparent: true,
-                };
+                let newWrite: PathValue | undefined = authorityStorage.getValueExactMaybeRejected(write.path, write.time);
+                if (newWrite && !newWrite.valid) {
+                    newWrite = undefined;
+                }
+                if (!newWrite) {
+                    newWrite = {
+                        path, valid: true, time: write.time, locks: [], lockCount: 0, value: undefined, canGCValue: true, isTransparent: true,
+                    };
+                }
                 newWrite = { ...newWrite };
                 // Use a time very slightly after, so it clobbers the write, and any writes before it, but none after.
                 newWrite.time = write.time;
@@ -271,7 +284,7 @@ function predictCallBase(config: {
         // If we already received the actual call, we can't add the prediction, as... the invalidation
         //      code won't properly immediately reject our prediction, as we are not the authority on the
         //      path, so it treats it as source of truth.
-        if (authorityStorage.getValueAtTime(pathResultWrite, undefined)?.value) {
+        if (authorityStorage.getValueAtOrBeforeTime(pathResultWrite, undefined)?.value) {
             if (Querysub.DEBUG_PREDICTIONS || Querysub.DEBUG_CALLS) {
                 console.log(magenta(`Abort predict call, already received call result`), `${call.DomainName}.${call.FunctionId}`);
             }
@@ -347,7 +360,7 @@ function predictCallBase(config: {
             let predictionsCopy = cborEncoder().decode(cborEncoder().encode(predictions)) as typeof predictions;
             for (let predict of predictionsCopy.writes ?? []) {
                 if (predict.path === pathResultWrite) continue;
-                let finalValueObj = authorityStorage.getValueAtTime(predict.path, afterTime);
+                let finalValueObj = authorityStorage.getValueAtOrBeforeTime(predict.path, afterTime);
                 if (!authorityStorage.isSynced(predict.path)) continue;
 
                 let finalValue = pathValueSerializer.getPathValue(finalValueObj);

package/src/5-diagnostics/GenericFormat.tsx

@@ -5,7 +5,7 @@ import { qreact } from "../4-dom/qreact";
 import preact, { ContextType } from "preact";
 import { errorMessage, warnMessage } from "../library-components/colors";
 import { URLParam } from "../library-components/URLParam";
-import { Querysub } from "../4-querysub/QuerysubController";
+import { Querysub } from "../4-querysub/Querysub";
 
 export { errorMessage, warnMessage };
 

package/src/5-diagnostics/qreactDebug.tsx

@@ -5,7 +5,7 @@ import { getPathFromStr, getPathStr } from "../path";
 import { delay } from "socket-function/src/batching";
 import { logErrors } from "../errors";
 import { clientWatcher } from "../1-path-client/pathValueClientWatcher";
-import { Querysub } from "../4-querysub/QuerysubController";
+import { Querysub } from "../4-querysub/Querysub";
 import { closeAllModals, showModal } from "./Modal";
 import { FullscreenModal, showFullscreenModal } from "./FullscreenModal";
 import { css } from "typesafecss";
@@ -295,7 +295,7 @@ class WatchModal extends qreact.Component<{
                                 if (filter && !path.toLowerCase().includes(filter)) {
                                     return undefined;
                                 }
-                                let valueObj = authorityStorage.getValueAtTime(path);
+                                let valueObj = authorityStorage.getValueAtOrBeforeTime(path);
                                 let value = pathValueSerializer.getPathValue(valueObj);
                                 let valueStr = String(value);
                                 try {

package/src/archiveapps/archiveGCEntry.tsx

@@ -1,6 +1,6 @@
 import "../inject";
 
-import { Querysub } from "../4-querysub/QuerysubController";
+import { Querysub } from "../4-querysub/Querysub";
 import { logErrors } from "../errors";
 import { isNodeTrue, timeInDay, timeInHour } from "socket-function/src/misc";
 import path from "path";

package/src/archiveapps/archiveJoinEntry.ts

@@ -2,14 +2,14 @@ import "../inject";
 
 import { logErrors } from "../errors";
 import { PathValueArchives, pathValueArchives } from "../0-path-value-core/pathValueArchives";
-import { ARCHIVE_FLUSH_LIMIT, PathValue, VALUE_GC_THRESHOLD } from "../0-path-value-core/pathValueCore";
+import { ARCHIVE_FLUSH_LIMIT, ARCHIVE_STABLE_THRESHOLD, PathValue } from "../0-path-value-core/pathValueCore";
 import { runInfinitePollCallAtStart } from "socket-function/src/batching";
 import { measureBlock } from "socket-function/src/profiling/measure";
 import { pathValueSerializer } from "../-h-path-value-serialize/PathValueSerializer";
 import { ArchiveTransaction, FileInfo } from "../0-path-value-core/archiveLocks/ArchiveLocks";
 import { formatNumber } from "socket-function/src/formatting/format";
 import { isNodeTrue, sort } from "socket-function/src/misc";
-import { Querysub } from "../4-querysub/QuerysubController";
+import { Querysub } from "../4-querysub/Querysub";
 import { magenta } from "socket-function/src/formatting/logColors";
 import { PathRouter } from "../0-path-value-core/PathRouter";
 import { disablePathAuditer } from "../diagnostics/pathAuditerCallback";
@@ -129,7 +129,7 @@ async function main() {
 
     if (yargObj.watch) {
         console.log("Running in watch mode.");
-        await runInfinitePollCallAtStart(VALUE_GC_THRESHOLD * 0.8, runGenesisJoinIteration);
+        await runInfinitePollCallAtStart(ARCHIVE_STABLE_THRESHOLD * 0.8, runGenesisJoinIteration);
     } else {
         try {
             await runGenesisJoinIteration({ force: true });

package/src/config.ts

@@ -89,8 +89,12 @@ export function getNotifyEmails() {
     return Array.from(new Set([...(yargObj.notifyemails || []), ...(querysubConfig().notifyemails || [])]));
 }
 
+let isClient: boolean | undefined;
 export function baseIsClient() {
-    return !isNode() || yargObj.client;
+    if (isClient === undefined) {
+        isClient = !isNode() || yargObj.client;
+    }
+    return isClient;
 }
 
 export function isRecovery() {

package/src/config2.ts

@@ -8,20 +8,22 @@ import { AuthoritySpec } from "./0-path-value-core/PathRouter";
 import { parseFilterable } from "./misc/filterable";
 import { lazy } from "socket-function/src/caching";
 
-let isInCall = false;
 export function isClient() {
-    isInCall = true;
-    try {
-        return !isNode() || baseIsClient() || !isInCall && !hasArchivesPermissions();
-    } finally {
-        isInCall = false;
-    }
+    return baseIsClient();
 }
 
 export function isServer() {
     return !isClient();
 }
 
+/**
+    If we need to evaluate valid states, it means we need to store the full history, which is expensive, and we need to request the full history.
+        - AND, We cannot. have any optimizations to do with having no locks because something, just because it has no locks doesn't mean the previous values can be removed, as they might be dependent on by a different lock entirely. 
+*/
+export function evaluateValidStates() {
+    return isServer();
+}
+
 // NOTE: getOurAuthorities moved to PathRouterHashOverrides, and renamed to getOurAuthoritySpec
 
 

package/src/deployManager/components/CommitModal.tsx

@@ -3,7 +3,7 @@ import { SocketFunction } from "socket-function/SocketFunction";
 import { qreact } from "../../4-dom/qreact";
 import { css } from "../../4-dom/css";
 import { MachineServiceController } from "../machineSchema";
-import { Querysub } from "../../4-querysub/QuerysubController";
+import { Querysub } from "../../4-querysub/Querysub";
 import { InputLabel } from "../../library-components/InputLabel";
 import { DropdownSelector } from "../../library-components/DropdownSelector";
 import { closeAllModals } from "../../5-diagnostics/Modal";

package/src/deployManager/components/DeployProgressView.tsx

@@ -2,7 +2,7 @@ import { css } from "typesafecss";
 import { qreact } from "../../4-dom/qreact";
 import { formatDateJSX } from "../../misc/formatJSX";
 import { formatTime } from "socket-function/src/formatting/format";
-import { Querysub } from "../../4-querysub/QuerysubController";
+import { Querysub } from "../../4-querysub/Querysub";
 
 module.hotreload = true;
 

package/src/deployManager/components/MachineDetailPage.tsx

@@ -9,7 +9,7 @@ import { ATag, Anchor } from "../../library-components/ATag";
 import { ShowMore } from "../../library-components/ShowMore";
 import { managementPageURL } from "../../diagnostics/managementPages";
 import { t } from "../../2-proxy/schema2";
-import { Querysub } from "../../4-querysub/QuerysubController";
+import { Querysub } from "../../4-querysub/Querysub";
 import { getLogViewerParams } from "../../diagnostics/logs/IndexedLogs/LogViewerParams";
 
 export class MachineDetailPage extends qreact.Component {

package/src/deployManager/components/MachinesListPage.tsx

@@ -3,7 +3,7 @@ import { qreact } from "../../4-dom/qreact";
 import { MACHINE_RESYNC_INTERVAL, MachineServiceController } from "../machineSchema";
 import { css } from "typesafecss";
 import { t } from "../../2-proxy/schema2";
-import { Querysub } from "../../4-querysub/QuerysubController";
+import { Querysub } from "../../4-querysub/Querysub";
 import { currentViewParam, selectedMachineIdParam } from "../urlParams";
 import { formatNumber, formatVeryNiceDateTime } from "socket-function/src/formatting/format";
 import { sort } from "socket-function/src/misc";

package/src/deployManager/components/ServiceDetailPage.tsx

@@ -3,7 +3,7 @@ import { qreact } from "../../4-dom/qreact";
 import { MACHINE_RESYNC_INTERVAL, MachineServiceController, ServiceConfig } from "../machineSchema";
 import { css } from "typesafecss";
 import { t } from "../../2-proxy/schema2";
-import { Querysub } from "../../4-querysub/QuerysubController";
+import { Querysub } from "../../4-querysub/Querysub";
 import { currentViewParam, selectedServiceIdParam, selectedMachineIdParam } from "../urlParams";
 import { formatTime, formatVeryNiceDateTime } from "socket-function/src/formatting/format";
 import { InputPicker } from "../../library-components/InputPicker";

package/src/deployManager/components/ServicesListPage.tsx

@@ -3,7 +3,7 @@ import { qreact } from "../../4-dom/qreact";
 import { MachineServiceController, ServiceConfig } from "../machineSchema";
 import { css } from "typesafecss";
 import { t } from "../../2-proxy/schema2";
-import { Querysub } from "../../4-querysub/QuerysubController";
+import { Querysub } from "../../4-querysub/Querysub";
 import { currentViewParam, selectedServiceIdParam } from "../urlParams";
 import { formatNiceDateTime, formatTime, formatVeryNiceDateTime } from "socket-function/src/formatting/format";
 import { sort, timeInMinute } from "socket-function/src/misc";

package/src/deployManager/components/Tools.tsx

@@ -3,7 +3,7 @@ import { SocketFunction } from "socket-function/SocketFunction";
 import { qreact } from "../../4-dom/qreact";
 import { css } from "typesafecss";
 import { t } from "../../2-proxy/schema2";
-import { Querysub } from "../../4-querysub/QuerysubController";
+import { Querysub } from "../../4-querysub/Querysub";
 import { MachineServiceController, ServiceConfig } from "../machineSchema";
 import { MachinePicker } from "./MachinePicker";
 import { isDefined } from "../../misc";