querysub 0.340.0 → 0.342.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.340.0",
+  "version": "0.342.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
@@ -50,9 +50,9 @@
     "js-sha512": "^0.9.0",
     "node-forge": "https://github.com/sliftist/forge#e618181b469b07bdc70b968b0391beb8ef5fecd6",
     "pako": "^2.1.0",
-    "socket-function": "^0.143.0",
+    "socket-function": "^0.152.0",
     "terser": "^5.31.0",
-    "typesafecss": "^0.22.0",
+    "typesafecss": "^0.23.0",
     "yaml": "^2.5.0",
     "yargs": "^15.3.1"
   },

package/src/-a-archives/archivesBackBlaze.ts

@@ -501,6 +501,8 @@ export class ArchivesBackblaze {
         return api;
     });
 
+    // Keep track of when we last reset because of a 503
+    private last503Reset = 0;
     // IMPORTANT! We must always CATCH AROUND the apiRetryLogic, NEVER inside of fnc. Otherwise we won't
     //  be able to recreate the auth token.
     private async apiRetryLogic<T>(
@@ -513,16 +515,40 @@ export class ArchivesBackblaze {
         } catch (err: any) {
             if (retries <= 0) throw err;
 
+            // If it's a 503 and it's been a minute since we last reset, then Wait and reset. 
+            if (
+                (err.stack.includes(`503`)
+                    || err.stack.includes(`"service_unavailable"`)
+                    || err.stack.includes(`"internal_error"`)
+                ) && Date.now() - this.last503Reset > 60 * 1000) {
+                this.log("503 error, waiting a minute and resetting: " + err.message);
+                await delay(10 * 1000);
+                // We check again in case, and in the very likely case that this is being run in parallel, we only want to reset once. 
+                if (Date.now() - this.last503Reset > 60 * 1000) {
+                    this.log("Resetting getAPI and getBucketAPI: " + err.message);
+                    this.last503Reset = Date.now();
+                    getAPI.reset();
+                    this.getBucketAPI.reset();
+                }
+                return this.apiRetryLogic(fnc, retries - 1);
+            }
+
+            // If the error is that the authorization token is invalid, reset getBucketAPI and getAPI
+            // If the error is that the bucket isn't found, reset getBucketAPI
+            if (err.stack.includes(`"expired_auth_token"`)) {
+                this.log("Authorization token expired");
+                getAPI.reset();
+                this.getBucketAPI.reset();
+                return this.apiRetryLogic(fnc, retries - 1);
+            }
+
             if (
                 err.stack.includes(`no tomes available`)
-                || err.stack.includes(`"service_unavailable"`)
                 || err.stack.includes(`ETIMEDOUT`)
-                || err.stack.includes(`"internal_error"`)
                 || err.stack.includes(`socket hang up`)
                 // Eh... this might be bad, but... I think we just get random 400 errors. If this spams errors,
                 //  we can remove this line.
                 || err.stack.includes(`400 Bad Request`)
-                || err.stack.includes(`"no tomes available"`)
                 || err.stack.includes(`getaddrinfo ENOTFOUND`)
             ) {
                 this.log(err.message + " retrying in 5s");
@@ -546,14 +572,6 @@ export class ArchivesBackblaze {
                 console.error(`getaddrinfo ENOTFOUND ${hostname}`, { lookupAddresses, resolveAddresses, apiUrl: api.apiUrl, fullError: err.stack });
             }
 
-            // If the error is that the authorization token is invalid, reset getBucketAPI and getAPI
-            // If the error is that the bucket isn't found, reset getBucketAPI
-            if (err.stack.includes(`"expired_auth_token"`)) {
-                this.log("Authorization token expired");
-                getAPI.reset();
-                this.getBucketAPI.reset();
-                return this.apiRetryLogic(fnc, retries - 1);
-            }
             // TODO: Handle if the bucket is deleted?
             throw err;
         }

package/src/2-proxy/PathValueProxyWatcher.ts

@@ -1,10 +1,10 @@
 import { measureCode, measureWrap, registerMeasureInfo } from "socket-function/src/profiling/measure";
 import { SocketFunction } from "socket-function/SocketFunction";
-import { deepCloneJSON, getKeys, isNode, recursiveFreeze, timeInMinute } from "socket-function/src/misc";
+import { binarySearchBasic, binarySearchBasic2, binarySearchIndex, deepCloneJSON, getKeys, insertIntoSortedList, isNode, recursiveFreeze, timeInMinute, timeInSecond } from "socket-function/src/misc";
 import { canHaveChildren, MaybePromise } from "socket-function/src/types";
 import { blue, green, magenta, red, yellow } from "socket-function/src/formatting/logColors";
 import { cache, cacheLimited, lazy } from "socket-function/src/caching";
-import { delay, runInfinitePoll } from "socket-function/src/batching";
+import { delay, runInSerial, runInfinitePoll } from "socket-function/src/batching";
 import { errorify, logErrors } from "../errors";
 import { appendToPathStr, getLastPathPart, getParentPathStr, getPathDepth, getPathFromStr, getPathIndex, getPathIndexAssert, getPathPrefix, getPathStr1, getPathStr2, getPathSuffix, slicePathStrToDepth } from "../path";
 import { addEpsilons } from "../bits";
@@ -36,6 +36,7 @@ import { formatPercent, formatTime } from "socket-function/src/formatting/format
 import { addStatPeriodic, interceptCalls, onAllPredictionsFinished, onTimeProfile } from "../-0-hooks/hooks";
 import { onNextPaint } from "../functional/onNextPaint";
 import { isAsyncFunction } from "../misc";
+import { isClient } from "../config2";
 
 // TODO: Break this into two parts:
 //  1) Run and get accesses
@@ -45,6 +46,10 @@ import { isAsyncFunction } from "../misc";
 
 const DEFAULT_MAX_LOCKS = 1000;
 
+// After this time we allow proxies to be reordered, even if there's flags that tell them not to be. 
+const MAX_PROXY_REORDER_BLOCK_TIME = timeInSecond * 10;
+
+let nextSeqNum = 1;
 let nextOrderSeqNum = 1;
 
 export interface WatcherOptions<Result> {
@@ -115,6 +120,7 @@ export interface WatcherOptions<Result> {
     debugName?: string;
 
     watchFunction: () => Result;
+    baseFunction?: Function;
 
     // Only called after all the reads are synced
     //  - getTriggeredWatcher will function correctly in this callback
@@ -214,10 +220,27 @@ export interface WatcherOptions<Result> {
 
     maxLocksOverride?: number;
 
+    /** Finish in the order we start in. This is required to prevent races. 
+     *      - Defaults to true client side if we're using Querysub.commitAsync
+     *      - If a number overrides the order, this is used when we're making predictions, so they trigger based on the order of their parent, instead of the order of when they started.
+     *      - Only applies the order based on other functions that have this flag set. 
+    */
+    finishInStartOrder?: number | boolean;
+
+    /** Only to be used for logging. Is VERY useful in certain circumstances  */
+    predictMetadata?: FunctionMetadata;
+
     // NOTE: The reason there isn't throttle support here is very frequently when you want to throttle one component rendering, it's because you have many components. So you actually want to throttle many components and have them throttle in conjunction with each other, which results in the logic becoming complicated.
     //  - But maybe we should support the single throttle case anyways?
 }
 
+export type DryRunResult = {
+    writes: PathValue[];
+    readPaths: Set<string>
+    readParentPaths: Set<string>;
+    result: unknown;
+};
+
 let harvestableReadyLoopCount = 0;
 let harvestableWaitingLoopCount = 0;
 let lastZombieCount = 0;
@@ -257,6 +280,7 @@ const getAllowedLockDomainsPrefixes = function getTrustedDomains(): string[] {
 };
 
 export type SyncWatcher = {
+    seqNum: number;
     options: WatcherOptions<any>;
 
     dispose: () => void;
@@ -306,7 +330,10 @@ export type SyncWatcher = {
     /** The key is the time we read at. This is required to create the lock.
      *  - Only utilized if we commit the write
     */
-    pendingAccesses: Map<Time | undefined, Map<string, PathValue>>;
+    pendingAccesses: Map<Time | undefined, Map<string, {
+        pathValue: PathValue;
+        noLocks: boolean;
+    }>>;
     pendingEpochAccesses: Map<Time | undefined, Set<string>>;
 
     // A necessity for react rendering, as rendering unsynced data almost always looks bad,
@@ -584,14 +611,22 @@ export class PathValueProxyWatcher {
                     readValues = new Map();
                     watcher.pendingAccesses.set(currentReadTime, readValues);
                 }
-                readValues.set(pathValue.path, pathValue);
+                let prevObj = readValues.get(pathValue.path);
+                let noLocks = watcher.options.noLocks || watcher.options.unsafeNoLocks || false;
+                if (!prevObj) {
+                    readValues.set(pathValue.path, { pathValue, noLocks });
+                } else {
+                    prevObj.pathValue = pathValue;
+                    // It can only be no locks if it's always no locks (prev && current)
+                    prevObj.noLocks = prevObj.noLocks && noLocks;
+                }
             }
         }
 
         return pathValue;
     };
     public getCallback = (pathStr: string, syncParentKeys?: "parentKeys", readTransparent?: "readTransparent"): { value: unknown } | undefined => {
-        if (PathValueProxyWatcher.BREAK_ON_READS.size > 0 && proxyWatcher.isAllSynced()) {
+        if (PathValueProxyWatcher.BREAK_ON_READS.size > 0 && (proxyWatcher.isAllSynced() || this)) {
             // NOTE: We can't do a recursive match, as the parent paths include the 
             //  root, which is constantly read, but not relevant.
             if (PathValueProxyWatcher.BREAK_ON_READS.has(pathStr)) {
@@ -1045,8 +1080,17 @@ export class PathValueProxyWatcher {
         }
 
         let now = Date.now();
+        let debugName = (
+            options.debugName
+            || options.watchFunction.name
+            || options.watchFunction.toString().replaceAll("\n", "\\n").replaceAll(/ +/g, " ").slice(0, 50)
+        );
+        if (debugName === "watchFunction" && options.baseFunction) {
+            debugName = options.baseFunction.name || options.baseFunction.toString().replaceAll("\n", "\\n").replaceAll(/ +/g, " ").slice(0, 50);
+        }
         let watcher: SyncWatcher = {
-            debugName: options.debugName || options.watchFunction.name || options.watchFunction.toString().replaceAll("\n", "\\n").replaceAll(/ +/g, " ").slice(0, 50),
+            seqNum: nextSeqNum++,
+            debugName,
             dispose: () => { },
             disposed: false,
             onInnerDisposed: [],
@@ -1091,6 +1135,7 @@ export class PathValueProxyWatcher {
             hackHistory: [],
             createTime: getTimeUnique(),
         };
+        addToProxyOrder(watcher);
         const SHOULD_TRACE = this.SHOULD_TRACE(watcher);
         const proxy = this.proxy;
 
@@ -1131,6 +1176,19 @@ export class PathValueProxyWatcher {
                 watcher.pendingUnsyncedAccesses.size > 0
                 || watcher.pendingUnsyncedParentAccesses.size > 0
                 || watcher.specialPromiseUnsynced
+                || isProxyBlockedByOrder(watcher)
+            );
+        };
+        const getReadyToCommit = () => {
+            let blocked = isProxyBlockedByOrder(watcher);
+            if (blocked) {
+                console.info(`Proxy ${watcher.debugName} is blocked by order`);
+            }
+            return (
+                watcher.lastUnsyncedAccesses.size === 0
+                && watcher.lastUnsyncedParentAccesses.size === 0
+                && !watcher.lastSpecialPromiseUnsynced
+                && !isProxyBlockedByOrder(watcher)
             );
         };
         function afterTrigger() {
@@ -1142,6 +1200,7 @@ export class PathValueProxyWatcher {
         }
 
         function dispose() {
+            if (watcher.disposed) return;
             watcher.disposed = true;
             clientWatcher.unwatch(trigger);
             self.allWatchers.delete(watcher);
@@ -1152,6 +1211,9 @@ export class PathValueProxyWatcher {
             }
 
             self.allWatchersLookup.delete(trigger);
+
+            // TODO: Is this guaranteed to be called all the time? What about nested proxy watchers?
+            void finishProxyAndTriggerNext(watcher);
         }
         function runWatcher() {
             watcher.pendingWrites.clear();
@@ -1169,6 +1231,7 @@ export class PathValueProxyWatcher {
             // IMPORTANT! Reset onInnerDisposed, so onCommitFinished doesn't result in a callback
             //  per time we wan the watcher!
             watcher.onInnerDisposed = [];
+            watcher.specialPromiseUnsynced = false;
 
             // NOTE: If runAtTime is undefined, the writeTime will be undefined, causing us to read the latest data.
             //  When we finish running we will determine a lock time > any received times.
@@ -1219,18 +1282,21 @@ export class PathValueProxyWatcher {
                             //  to do the permissions checks if they want them
                             throw new Error(`Nested synced function calls are not allowed. Call the function directly, or use Querysub.onCommitFinished to wait for the function to finish.`);
                         } else if (handling === "after" || handling === undefined) {
-                            // We need to wait for predictions to finish, otherwise we run into situations
-                            //  where we call a function which should change a parameter we want to pass
-                            //  to another function, but because the first call didn't predict, the second
-                            //  call gets a different values, causing all kinds of issues.
-                            if (watcher.pendingCalls.length === 0) {
-                                let waitPromise = onAllPredictionsFinished();
-                                if (waitPromise) {
-                                    proxyWatcher.triggerOnPromiseFinish(waitPromise, {
-                                        waitReason: "Waiting for predictions to finish",
-                                    });
-                                }
-                            }
+                            // UPDATE: This isn't feasible. For one, it has n squared complexity. Also, I don't think it would work in the case if you make two function calls within one function? So it seems like it would only ever work if the function calls were in different functions?
+                            // UPDATE: Use `if (Querysub.syncAnyPredictionsPending()) return;` at the start of a function if you want to emulate this behavior
+                            //  - I think the solution for this is that the second function itself needs to wait for all predictions to finish. It's annoying, but I think it's required...
+                            // // We need to wait for predictions to finish, otherwise we run into situations
+                            // //  where we call a function which should change a parameter we want to pass
+                            // //  to another function, but because the first call didn't predict, the second
+                            // //  call gets a different values, causing all kinds of issues.
+                            // if (watcher.pendingCalls.length === 0) {
+                            //     let waitPromise = onAllPredictionsFinished();
+                            //     if (waitPromise) {
+                            //         proxyWatcher.triggerOnPromiseFinish(waitPromise, {
+                            //             waitReason: "Waiting for predictions to finish",
+                            //         });
+                            //     }
+                            // }
 
                             watcher.pendingCalls.push({ call, metadata });
                         } else if (handling === "ignore") {
@@ -1280,13 +1346,14 @@ export class PathValueProxyWatcher {
                 watcher.permissionsChecker = undefined;
             }
 
+
+            let anyUnsynced = watcher.hasAnyUnsyncedAccesses();
+
             watcher.lastUnsyncedAccesses = watcher.pendingUnsyncedAccesses;
             watcher.lastUnsyncedParentAccesses = watcher.pendingUnsyncedParentAccesses;
             watcher.lastSpecialPromiseUnsynced = watcher.specialPromiseUnsynced;
-            const specialPromiseUnsynced = watcher.specialPromiseUnsynced;
-            watcher.specialPromiseUnsynced = false;
 
-            let anyUnsynced = watcher.hasAnyUnsyncedAccesses();
+            // TODO: Add promise delays as well as the finish order reordering delays to the sync timings. 
             if (watcher.options.logSyncTimings) {
                 if (anyUnsynced) {
                     watcher.logSyncTimings = watcher.logSyncTimings || {
@@ -1387,12 +1454,15 @@ export class PathValueProxyWatcher {
                         }, 60000);
                     }
                     watcher.countSinceLastFullSync++;
+                    if (watcher.countSinceLastFullSync > 10) {
+                        console.warn(`Watcher ${watcher.debugName} has been unsynced for ${watcher.countSinceLastFullSync} times. This is fine, but maybe optimize it. Why is it cascading?`, watcher.lastUnsyncedAccesses, watcher.lastUnsyncedParentAccesses, watcher.options.watchFunction);
+                    }
                     if (watcher.countSinceLastFullSync > 500) {
                         debugger;
                         // NOTE: Using forceEqualWrites will also fix this a lot of the time, such as when
                         //  a write contains random numbers or dates.
                         let errorMessage = `Too many attempts (${watcher.countSinceLastFullSync}) to sync with different values. If you are reading in a loop, make sure to read all the values, instead of aborting the loop if a value is not synced. ALSO, make sure you don't access paths with Math.random() or Date.now(). This will prevent the sync loop from ever stabilizing.`;
-                        if (specialPromiseUnsynced) {
+                        if (watcher.lastSpecialPromiseUnsynced) {
                             errorMessage += ` A promise is being accessed, so it is possible triggerOnPromiseFinish is being used on a new promise every loop, which cannot work (you MUST cache MaybePromise and replace the value with a non-promise, otherwise it will never be available synchronously!)`;
                         }
                         errorMessage += ` (${watcher.debugName}})`;
@@ -1468,7 +1538,9 @@ export class PathValueProxyWatcher {
                         if (!readTime) {
                             readTime = writeTime;
                         }
-                        for (let value of values.values()) {
+                        for (let valueObj of values.values()) {
+                            if (valueObj.noLocks) continue;
+                            let value = valueObj.pathValue;
                             // If any value has no locks, AND is local, it won't be rejected, so we don't need to lock it
                             if (value.lockCount === 0 && value.path.startsWith(LOCAL_DOMAIN_PATH)) {
                                 continue;
@@ -1544,6 +1616,11 @@ export class PathValueProxyWatcher {
                     throw new Error(`Too many locks for ${watcher.debugName} (${locks.length} > ${maxLocks}). Use Querysub.noLocks(() => ...) around code that is accessing too many values, assuming you don't want to lock them. You can override max locks with maxLocksOverride (in options / functionMetadata).`);
                 }
 
+
+                // if (debugName.includes("setBookNodes")) {
+                //     debugger;
+                // }
+
                 setValues = clientWatcher.setValues({
                     values: watcher.pendingWrites,
                     eventPaths: watcher.pendingEventWrites,
@@ -1556,37 +1633,37 @@ export class PathValueProxyWatcher {
                 });
             }
 
-            // TODO: Maybe return this in some way, so dryRun can know what calls we want to call?
-            for (let { call, metadata } of watcher.pendingCalls) {
-                // The calls have to happen after our local writes. This is because they are likely to
-                //  influence the local writes, and we don't want our local writes to be always invalidated
-                call.runAtTime = getNextTime();
-                logErrors(runCall(call, metadata));
-                watcher.options.onCallCommit?.(call, metadata);
-            }
+            doCallCreation(watcher, () => {
+                // TODO: Maybe return this in some way, so dryRun can know what calls we want to call?
+                for (let { call, metadata } of watcher.pendingCalls) {
+                    // The calls have to happen after our local writes. This is because they are likely to
+                    //  influence the local writes, and we don't want our local writes to be always invalidated
+                    call.runAtTime = getNextTime();
+                    logErrors(runCall(call, metadata));
+                    watcher.options.onCallCommit?.(call, metadata);
+                }
+            });
 
             return setValues;
 
         }
         const hasUnsyncedBefore = measureWrap(function proxyWatchHasUnsyncedBefore() {
-            // NOTE: We COULD remove any synced values, however... we will generally sync all values at once,
-            //      so we don't really need to optimize the cascading case here. Also... deleting values
-            //      requires cloning while we iterate, as well as mutating the set, which probably makes the
-            //      non-cascading case slower.
-            let anyUnsynced = false;
+            // NOTE: We COULD remove any synced values from lastUnsyncedAccesses, however... we will generally sync all values at once, so we don't really need to optimize the cascading case here. Also... deleting values requires cloning while we iterate, as well as mutating the set, which probably makes the non-cascading case slower.
             for (let path of watcher.lastUnsyncedAccesses) {
                 if (!authorityStorage.isSynced(path)) {
-                    anyUnsynced = true;
+                    return true;
                 }
             }
             for (let path of watcher.lastUnsyncedParentAccesses) {
                 if (!authorityStorage.isParentSynced(path)) {
-                    anyUnsynced = true;
+                    return true;
                 }
             }
+            // Actually, a lot of calls are going to be blocked by the proxy order, and we want to run them in parallel. So we have all the values synced, so we're ready to finish them when the next one finally finishes. 
+            //if (isProxyBlockedByOrder(watcher)) return true;
             // NOTE: We don't check promises as they often access non-synced code, and so we might retrigger
             //      and not use the same promise, so it might be wrong to check them.
-            return anyUnsynced;
+            return false;
         });
         function logUnsynced() {
             let anyLogged = false;
@@ -1718,11 +1795,7 @@ export class PathValueProxyWatcher {
             const nonLooping = options.runImmediately || options.allowUnsyncedReads;
 
             const readyToCommit = (
-                nonLooping || (
-                    watcher.lastUnsyncedAccesses.size === 0
-                    && watcher.lastUnsyncedParentAccesses.size === 0
-                    && !watcher.lastSpecialPromiseUnsynced
-                )
+                nonLooping || getReadyToCommit()
             );
 
             if (!nonLooping) {
@@ -1919,12 +1992,7 @@ export class PathValueProxyWatcher {
     /** Run the same as usual, but instead of committing writes, returns them. */
     public async dryRunFull(
         options: Omit<WatcherOptions<any>, "onResultUpdated" | "onWriteCommitted">
-    ): Promise<{
-        writes: PathValue[];
-        readPaths: Set<string>
-        readParentPaths: Set<string>;
-        result: unknown;
-    }> {
+    ): Promise<DryRunResult> {
         type Result = {
             writes: PathValue[];
             readPaths: Set<string>
@@ -1934,7 +2002,7 @@ export class PathValueProxyWatcher {
         let onResult!: (result: Result) => void;
         let onError!: (error: Error) => void;
         let resultPromise = new Promise<Result>((resolve, reject) => { onResult = resolve; onError = reject; });
-        this.createWatcher({
+        let watcher = this.createWatcher({
             ...options,
             canWrite: true,
             dryRun: true,
@@ -1953,7 +2021,8 @@ export class PathValueProxyWatcher {
                 }
             }
         });
-        return await resultPromise;
+        let result = await resultPromise;
+        return result;
     }
 
 
@@ -1981,7 +2050,7 @@ export class PathValueProxyWatcher {
     }
 
     public isAllSynced() {
-        return !this.getTriggeredWatcher().hasAnyUnsyncedAccesses();
+        return !this.getTriggeredWatcherMaybeUndefined()?.hasAnyUnsyncedAccesses();
     }
     /** @deprecated try not to call getTriggeredWatcherMaybeUndefined, and instead try to call Querysub helper
      *      functions. getTriggeredWatcherMaybeUndefined exposes too much of our interface, which we need
@@ -2289,3 +2358,100 @@ registerMeasureInfo(() => {
     triggerCount = 0;
     return `${formatPercent(current)} paint dropped triggers`;
 });
+
+
+
+
+// #region Proxy Ordering
+let proxiesOrdered: SyncWatcher[] = [];
+function getProxyOrder(proxy: SyncWatcher): string | undefined {
+    // We can't wait if we're running immediately. 
+    if (proxy.options.runImmediately) return undefined;
+
+    let value = proxy.options.finishInStartOrder;
+
+    if (value === false) return undefined;
+    if (value === true) {
+        value = proxy.createTime;
+    }
+    if (value === undefined) return undefined;
+    return getPathStr2(value.toFixed(10).padStart(30, "0") + "", proxy.seqNum + "");
+}
+function addToProxyOrder(proxy: SyncWatcher) {
+    let order = getProxyOrder(proxy);
+    if (order === undefined) return;
+    let index = binarySearchBasic(proxiesOrdered, x => getProxyOrder(x) || 0, order);
+    if (index >= 0) {
+        throw new Error(`Proxy ${proxy.debugName} is already in the proxy order at index ${index}? This shouldn't be possible, as the sequence number should make it unique. `);
+    }
+    insertIntoSortedList(proxiesOrdered, x => getProxyOrder(x) || 0, proxy);
+    setTimeout(() => {
+        let index = binarySearchBasic(proxiesOrdered, x => getProxyOrder(x) || 0, order);
+        if (index >= 0) {
+            if (proxiesOrdered.length > (index + 1)) {
+                // Only warn if there's actually proxies after us. 
+                console.warn(`Allowing out-of-order proxy finishing due to long-running proxy not resolving. Not resolving: ${proxy.debugName} timed out after ${formatTime(MAX_PROXY_REORDER_BLOCK_TIME)}`);
+            }
+            void finishProxyAndTriggerNext(proxy, true);
+        }
+    }, MAX_PROXY_REORDER_BLOCK_TIME);
+}
+
+//  - This should be fine though, because if we're doing this for an async call, it means they're already expecting the result back within a promise. So waiting another promise shouldn't mess up the ordering. 
+const finishProxyAndTriggerNext = runInSerial(
+    async function finishProxyAndTriggerNext(proxy: SyncWatcher, fromTimeout: boolean = false) {
+        let order = getProxyOrder(proxy);
+        if (order === undefined) return;
+        let index = binarySearchBasic(proxiesOrdered, x => getProxyOrder(x) || 0, order);
+        if (index < 0) {
+            console.warn(`Proxy ${proxy.debugName} is not in the proxy order at index ${index}? This shouldn't be possible, don't we only dispose it once? `);
+            return;
+        }
+
+        // NOTE: We have to wait to the next tick, as finish order code is most often on for async functions, in which case, even though we will have called onResultUpdated, the caller He's waiting on a promise, so we need to give it a tick to actually receive the value. 
+        //  - This shouldn't cause any actual slowdown because people are calling the functions and usually awaiting them, so they won't notice a difference. 
+        // HACK: We wait 10 times because I guess there's a lot of change promises. I found five works, but adding more is fine. This is pretty bad, but... I don't think there's anything that can possibly be expecting an ordered function to finish synchronously. Anything that is waiting on the ordered function is going to actually be waiting with an await, so we could iterate 100 times here and it wouldn't break anything.
+        for (let i = 0; i < 10; i++) {
+            await Promise.resolve();
+        }
+
+        proxiesOrdered.splice(index, 1);
+        let next = proxiesOrdered[index];
+        // Only trigger if it's the first entry and therefore it won't be blocked by the previous proxy, or, of course, if it's from a timeout, In which case, it won't be blocked anyway. 
+        if (next && (index === 0 || fromTimeout)) {
+            console.info(`Triggering next proxy in order: ${next.debugName}`, next.options.baseFunction || next.options.watchFunction);
+            next.explicitlyTrigger({
+                newParentsSynced: new Set(),
+                pathSources: new Set(),
+                paths: new Set(),
+                extraReasons: [`Delayed due to proxy order enforcement. Previous proxy finished, so we can now finish. Previous was ${proxy.debugName}`],
+            });
+        }
+    }
+);
+function isProxyBlockedByOrder(proxy: SyncWatcher): boolean {
+    let order = getProxyOrder(proxy);
+    if (order === undefined) return false;
+    let index = binarySearchBasic(proxiesOrdered, x => getProxyOrder(x) || 0, order);
+    if (index <= 0) return false;
+    return true;
+}
+
+let currentCallCreationProxy: SyncWatcher | undefined = undefined;
+function doCallCreation(proxy: SyncWatcher, code: () => void) {
+    let prev = currentCallCreationProxy;
+    currentCallCreationProxy = proxy;
+    try {
+        return code();
+    } finally {
+        currentCallCreationProxy = prev;
+    }
+}
+export function debug_getQueueOrder() {
+    return proxiesOrdered;
+}
+export function getCurrentCallCreationProxy() {
+    return currentCallCreationProxy;
+}
+
+// #endregion Proxy Ordering

package/src/2-proxy/garbageCollection.ts

@@ -119,7 +119,8 @@ let getWatchEvaluator = lazy((): {
                 if (nextGetReadLocks) {
                     lastResult.readLocks = [];
                     for (let value of watcher.pendingAccesses) {
-                        for (let v of value[1].values()) {
+                        for (let vObj of value[1].values()) {
+                            let v = vObj.pathValue;
                             lastResult.readLocks.push({
                                 path: v.path,
                                 startTime: v.time,

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

@@ -37,13 +37,14 @@ export function getExportPath(functionId: string): string {
 
 export type FunctionMetadata<F = unknown> = {
     nopredict?: boolean;
-    /** Delay functions commits by Querysub.DELAY_COMMIT_DELAY
-     *      - We collapse redundant delayed calls, by looking at reads/writes (and if all
-     *           writes are clobbered by a later writer, then the earlier write is redundant).
-     *      - IMPORTANT! If you delay a function which writes to A, then write to B, which triggers
-     *          a remote server to read A, the server will read the old value of A, which breaks things.
-     *          If this is happening, either stop delaying writes to A, OR, call flushDelayedFunctions
-     *          before writing to B.
+    /** Removes unnecessary function calls by first delaying by Querysub.DELAY_COMMIT_DELAY, Then looking at their predictions and removing ones where their predictions completely clobber the other ones.
+     *      - Determines unnecessary calls via our function prediction. If our function is prediction is wrong, we might remove calls that shouldn't be removed. 
+     *      - This is quite dangerous, but extremely useful for things such as editors when you want to type and have things update quickly, but you don't want to spam the server with calls. 
+     *      - Only applied for clients.
+     *      - We will always preserve the order of function calls in the same schema, so if you make another function call that doesn't have delay commit in the same schema, then we will forcefully commit all the delayed commit functions first.
+     *          - This shouldn't cause an excessive amount of function commits. The delayed commit time is very small, maybe around five seconds. And if you are regularly having commits that are faster than that, that aren't delayed commit, then you're already having a lot of commits. And we will still remove unnecessary calls, even if we have to commit them earlier than the delay. 
+     *      - IMPORTANT! Our check for if values should be removed isn't perfect. If you write to a path that another value reads from, and then it writes that value to a path that we then read from... This would mean our value can't be clobbered as it has side effects which would affect values that could regularly clobber us. However, we don't detect this case, and we will just allow it to be clobbered.
+     *          - However, when we clobber values, we will cancel them client-side fairly quickly, so it should be apparent if this bug happens, in which case the writes you're doing are too complicated and you shouldn't be using delay commit. Delay commit is only really intended for simple cases, such as the user presses a key and then you set some text equal to a result based on that key (It doesn't work with deltas, You need to be forcefully setting the value). 
      */
     delayCommit?: boolean;