querysub 0.437.0 → 0.438.0

package/src/2-proxy/PathValueProxyWatcher.ts

@@ -1,2542 +1,2542 @@
-import { measureCode, measureWrap, registerMeasureInfo } from "socket-function/src/profiling/measure";
-import { SocketFunction } from "socket-function/SocketFunction";
-import { binarySearchBasic, binarySearchBasic2, binarySearchIndex, deepCloneJSON, getKeys, insertIntoSortedList, isNode, recursiveFreeze, sort, 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, 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";
-import { getThreadKeyCert } from "../-a-auth/certs";
-import { ActionsHistory } from "../diagnostics/ActionsHistory";
-import { registerResource } from "../diagnostics/trackResources";
-import { ClientWatcher, WatchSpecData, clientWatcher } from "../1-path-client/pathValueClientWatcher";
-import { createPathValueProxy, getPathFromProxy, getProxyPath, getProxyPathAndWatch, isValueProxy, isValueProxy2 } from "./pathValueProxy";
-import { authorityStorage, compareTime, ReadLock, epochTime, getNextTime, MAX_ACCEPTED_CHANGE_AGE, PathValue, Time, getCreatorId, getTimeUnique } from "../0-path-value-core/pathValueCore";
-import { runCodeWithDatabase, rawSchema } from "./pathDatabaseProxyBase";
-import debugbreak from "debugbreak";
-import { pathValueCommitter } from "../0-path-value-core/PathValueController";
-import { pathValueSerializer } from "../-h-path-value-serialize/PathValueSerializer";
-import { registerPeriodic } from "../diagnostics/periodic";
-import { remoteWatcher } from "../1-path-client/RemoteWatcher";
-import { Schema2, Schema2Fncs } from "./schema2";
-import { devDebugbreak, getDomain, isDynamicallyLoading, isPublic } from "../config";
-
-import type { CallSpec } from "../3-path-functions/PathFunctionRunner";
-import type { FunctionMetadata } from "../3-path-functions/syncSchema";
-
-import { DEPTH_TO_DATA, MODULE_INDEX, getCurrentCall, getCurrentCallObj } from "../3-path-functions/PathFunctionRunner";
-import { interceptCallsBase, runCall } from "../3-path-functions/PathFunctionHelpers";
-import { deepCloneCborx } from "../misc/cloneHelpers";
-import { formatNumber, 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
-//  2) Commit/watch/unwatch
-// With a harness that joins the two parts in a loop (mostly powered by clientWatcher,
-//      which can run the trigger loop).
-
-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> {
-    /** NOTE: If you try to run too far in the past, an error will occur.
-     *  - This both sets the read time, and write time.
-     *  - setCurrentReadTime can also set the read time (but runAtTime is the only
-     *      way to set the write time).
-     */
-    runAtTime?: Time;
-
-    /** NOTE: Write values are only committed after we have all reads synced. */
-    canWrite?: boolean;
-
-    /** ONLY allowed if the writes and reads are all local (throws if any non-local accesses are attempted).
-     *  - Stops lock creation. This might increase speed?
-     */
-    noLocks?: boolean;
-    /** No locks, without the local-only restriction. A lot more unsafe. Don't use for any writes
-     *      that will eventually be committed (we only use it in prediction code, and GC). */
-    unsafeNoLocks?: boolean;
-
-    /** Causes us to read without counting as reading, so we don't sync any values, or
-     *      add them to our locks. Usually only set temporarily inside of a watcher,
-     *      so it can read sync values in order to write non-synced side-effects, without
-     *      having to rerun if those synced values change (as the non-synced side-effects won't
-     *      be undone, so rerunning wouldn't matter).
-     *      - qreact uses this for component traversal to set disposing flags, as disposing flags
-     *          are non-synced, and just for optimization, so there's no reason to watch the component
-     *          hierarchy when changing them.
-     */
-    noSyncing?: boolean;
-
-
-    /** Doesn't allow reading any values, but... also causes allows the function to have
-     *      no readLocks! (so it can't be rejected)
-     *  - Still allows reading back your own writes though...
-     *  - Doesn't write object parents, which breaks Object.getKeys(), unless you use
-     *      atomicObjectWrite.
-     *  - Usually set with runImmediately
-     */
-    writeOnly?: boolean;
-
-    /** Ignore currentReadTime, and just read the latest. For use with doProxyOptions. */
-    forceReadLatest?: boolean;
-
-    /** If you are writing values you KNOW you won't reading back, set this flag to
-     *      prevent caching of the writes clientside (which is a lot more efficient).
-     *      - More for testing purposes, as the performance benefit is basically negligible,
-     *          and the memory impact is unlikely to be an issue unless you are writing huge values.
-     */
-    doNotStoreWritesAsPredictions?: boolean;
-
-    /** See PathValue.event */
-    eventWrite?: boolean;
-
-    /** By default we read values before we write to them, and don't write if the value
-     *      would be `===`. This is usually preferred, because unneeded writes are a lot
-     *      more expensive than unneeded reads. However, if you are writing a lot, and you
-     *      know the values will be different, you can set this to reduce the amount of reads.
-     *  This is implicitly used for atomic writes (both due to atomicObjectWrite, or atomicWrites: true),
-     *      otherwise almost all atomic writes would result in an infinite loop, as usually
-     *      objects aren't === (and we don't deep compare objects on writes).
-     */
-    forceEqualWrites?: boolean;
-
-    atomicWrites?: boolean;
-
-    debugName?: string;
-    source?: string;
-
-    watchFunction: () => Result;
-    baseFunction?: Function;
-
-    // Only called after all the reads are synced
-    //  - getTriggeredWatcher will function correctly in this callback
-    onResultUpdated?: (
-        result: { result: Result } | { error: string },
-        writes: PathValue[] | undefined,
-        watcher: SyncWatcher
-    ) => void;
-
-    onCallCommit?: (call: CallSpec, metadata: FunctionMetadata) => void;
-
-    /** Causes us to not actually write values (we still sync new values, etc),
-     *      we just don't actually commit any writes. */
-    dryRun?: boolean;
-
-    /** Runs immediately, returning immediately, not waiting for any values to synchronize.
-     *      - Also disposes it immediately, as it isn't watching any values
-     *      - Does not even START to synchronize any values
-    */
-    runImmediately?: boolean;
-
-    /** By default we call pathValueCommitter.waitForValuesToCommit. This skips that check. */
-    noWaitForCommit?: boolean;
-
-    /** HACK: Used in conjuction with specific callers to prevent disposing, so the watcher
-     *      can be reused for specific cases.
-     */
-    static?: boolean;
-
-    /** Runs the inner function and calls the callback, even if there are unsynced values. */
-    allowUnsyncedReads?: boolean;
-
-    // NOTE: We create a new checker every single run
-    getPermissionsCheck?: () => PermissionsChecker;
-
-    skipPermissionsCheck?: boolean;
-
-    /** Default is after, which runs nested calls after the function runs (and only if all the
-     *      data is synchronized)
-     *      "inline" results in calls being run immediately, instead of queued.
-     *          TODO: We can only inline calls on the same domain, as we don't have
-     *              permissions for calls on other domains. In this case we might want to throw
-     *              ("after" is complicated due to FunctionRunner).
-     * */
-    nestedCalls?: "throw" | "after" | "ignore" | "inline";
-
-    /** These domains are allowed to be referenced by locks. Can be overriden, so you can invalidate based on on other domains
-     *      (ex, predict the server from the client).
-     *      - Defaults to the current domain, which is the safest option (as invalidating based on other domains can cause
-     *          security issues, reliability issues, etc).
-     */
-    overrideAllowLockDomainsPrefixes?: string[];
-
-    /** See WatchSpec.orderGroup */
-    order?: number;
-    orderGroup?: number;
-
-    synchronousInit?: boolean;
-
-    overrides?: PathValue[];
-
-    // Triggers are also tracked if ProxyWatcher.TRACK_TRIGGERS (or ClientWatcher.DEBUG_TRIGGERS)
-    // Sometimes we need trigger tracking for delta watchers, so this isn't just for debugging
-    trackTriggers?: boolean;
-
-    // Fairly self explanatory. If there are nested createWatchers, instead of forking, we just
-    //  run them immediately.
-    inlineNestedWatchers?: boolean;
-
-    // Temporary indicates after becoming synchronizes it will immediately dispose itself
-    temporary?: boolean;
-
-    // MUCH faster for large data (which otherwise requires a deep clone), but if it does return a proxy, and you access it in non-commit, it will throw.
-    allowProxyResults?: boolean;
-
-    /** Prevents us from (ever) tracking this as a wasted evaluation.
-     *      (indicates that this function changes non-synced states)
-     *  - Ex, qreact's mounter sets this, as it changes the DOM.
-     *  - If you are watching for the purpose of logging, or writing to files, you would set this.
-     *  - A lot of serverside watchers will set this (such as PathFunctionRunner)
-     */
-    hasSideEffects?: boolean;
-
-    /** Takes any runs with the same runOncePerPaint (globally, across all watchers),
-     *      and only runs them once per paint per group. Any excessive runs will be culled,
-     *      with the latest call being rerun after the next paint.
-     *      - If "runImmediately" or "temporary" is set, the latest call won't be rerun after the
-     *          next paint (it will be dropped).
-     *      - This should often be an id unique to the specific watcher. Otherwise
-     *          you may have watchers left in a outdated state. However, this might be
-     *          what you want, it depends on the usecase.
-     */
-    runOncePerPaint?: string;
-
-    /** Logs time to go from unsynced to synced, and the paths that were unloaded.
-     *      - In order to tell what paths to pre-load, and how much time we are waiting to load data.
-     *      - Also to tell us how long and how many paths are loading on startup.
-    */
-    logSyncTimings?: boolean;
-
-    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;
-
-    /** AKA, isAllSynced is always true. Useful for cases when we want to show partially loaded values. */
-    commitAllRuns?: boolean;
-
-
-    /** Path values contain some information about all the paths that were written at once, which we call a transaction. We can use this to detect when we are missing part of a transaction and wait until we receive that part of the transaction. 
-        - If we don't wait, our writes will get rejected, and so the system will still be valid, however, there are a few reasons we want to avoid this:
-            - If we are trying to trigger external data, such as API calls, we want to reduce raise conditions. The values still might be rejected entirely, however, at least there won't be a partial read, whereas partial reads are significantly more common than rejections. 
-            - Rejections can cause view stuttering, where the view goes to a bad state before it goes to a good state. If we just wait for the transaction to complete before trying to commit a value, such as in function runner, we can remove this stutter.
-            - Waiting can be more efficient than committing it and having to reject it, especially if something else depends on our value and then it has to be rejected and rerun. 
-            - Not all writers will automatically rerun on rejections. They should be able to handle rejections. However, it might cause downtime and it might have to put the system into a partial recovery state. It's better to avoid this and just wait for the full transaction. 
-        - Because this is so useful and so cheap to calculate, this flag will be set by default by most commit-style templates. It should be safe to set in watch style templates, However, it's not on by default there as, technically speaking, waiting for incomplete transactions will cause higher latency to render, And by default we prefer to render fast and usually get it right rather than render slow and always render the right thing. 
-     */
-    waitForIncompleteTransactions?: boolean;
-
-    // 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;
-// NOTE: Only the % waiting for active watchers. Which... is fine
-addStatPeriodic({
-    title: "Performance|Watcher % Waiting",
-    getValue: () => {
-        let totalLoop = harvestableReadyLoopCount + harvestableWaitingLoopCount;
-        if (totalLoop === 0) return 0;
-        let frac = harvestableWaitingLoopCount / totalLoop;
-        harvestableWaitingLoopCount = 0;
-        harvestableReadyLoopCount = 0;
-        return frac;
-    },
-    format: formatPercent,
-});
-addStatPeriodic({
-    title: "Performance|Stalled Watchers",
-    getValue: () => lastZombieCount,
-});
-
-
-//  Used to prevent local rejections on remote values (as local functions aren't rerun)
-//  Also used for security on servers, so they can read from untrusted domains, but can't have values
-//      rejected by untrusted domains.
-const getAllowedLockDomainsPrefixes = function getTrustedDomains(): string[] {
-    if (isNode()) {
-        return [getPathStr1(getDomain())];
-    } else {
-        // TODO: We COULD allow non-local watches on clients? This would allow something such as...
-        //  clicking on a button to go the first page that no other user is on... to revert if
-        //  another user clicks at the same time and we race. Or... something? Maybe there
-        //  are no cases when we need it... and it would definitely slow things down, so...
-        //  maybe we just don't?
-        return [LOCAL_DOMAIN_PATH];
-    }
-};
-
-export type SyncWatcher = {
-    seqNum: number;
-    options: WatcherOptions<any>;
-
-    dispose: () => void;
-    disposed?: boolean;
-    // Reset every time the function is run, so this can be subscribed to every run, but will
-    //  only be called once the final commit.
-    onInnerDisposed: (() => void)[];
-    // Runs after any trigger happens (usually multiple triggers are required for a commit)
-    onAfterTriggered: (() => void)[];
-
-    // Not great, but... sometimes we just want to trigger the function
-    explicitlyTrigger: (changes?: WatchSpecData) => void;
-
-    hasAnyUnsyncedAccesses: () => boolean;
-
-    //  - epochTime results in reading the latest time
-    //  - time is exclusive, so if you set the time of an existing write, you won't
-    //      read back it's writes.
-    setCurrentReadTime: <T>(time: Time, code: () => T) => T;
-    //  NOTE: Use the setCurrentReadTime helper, to prevent accidentally
-    //      leaving the read time set (or use runAtTime in the options,
-    //      to set it forever).
-    currentReadTime: Time | undefined;
-    nextWriteTime: Time | undefined;
-
-    debugName: string;
-
-    // The changes which triggered the current run (or last run if we are not currently running).
-    triggeredByChanges: undefined | WatchSpecData;
-
-    pendingWrites: Map<string, unknown>;
-    pendingEventWrites: Set<string>;
-    pendingCalls: { call: CallSpec; metadata: FunctionMetadata }[];
-
-    pendingWatches: {
-        paths: Set<string>;
-        parentPaths: Set<string>;
-    };
-
-    // These aren't set until after a run finishes
-    lastWatches: {
-        paths: Set<string>;
-        parentPaths: Set<string>;
-    };
-
-
-    /** 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: PathValue;
-        noLocks: boolean;
-    }>>;
-    pendingEpochAccesses: Map<Time | undefined, Set<string>>;
-
-    // A necessity for react rendering, as rendering unsynced data almost always looks bad,
-    //  so we need to show the previously rendered data when we have unsynced data.
-    //  (Although, there is a certain pleasantness to showing SOME change extremely fast,
-    //  even if it's a somewhat broken state, so... we might at a mode to allow rendering
-    //  with unsynced data).
-    //  TODO: We might make this a function, and lazily calculate it. That way we can batch reads
-    //      without having to check isSynced?
-    // NOTE: The "pendingUnsynced" must ALWAYS also set pendingWatches
-    pendingUnsyncedAccesses: Set<string>;
-    lastUnsyncedAccesses: Set<string>;
-
-    pendingUnsyncedParentAccesses: Set<string>;
-    lastUnsyncedParentAccesses: Set<string>;
-
-    specialPromiseUnsynced: boolean;
-    lastSpecialPromiseUnsynced: boolean;
-    lastSpecialPromiseUnsyncedReason?: string;
-
-    consecutiveErrors: number;
-    countSinceLastFullSync: number;
-    lastSyncTime: number;
-    syncRunCount: number;
-    startTime: number;
-
-    lastEvalTime: number;
-    inThrottle?: boolean;
-
-    permissionsChecker?: PermissionsChecker;
-
-    /** Allows us to tag the object for heap analysis */
-    tag: SyncWatcherTag;
-
-    hackHistory: { message: string; time: number }[];
-
-    createTime: number;
-
-    logSyncTimings?: {
-        startTime: number;
-        unsyncedPaths: Set<string>;
-        unsyncedStages: {
-            paths: string[];
-            time: number;
-        }[];
-    };
-}
-function addToHistory(watcher: SyncWatcher, message: string) {
-    watcher.hackHistory.push({ message, time: Date.now() });
-}
-
-
-// NOTE: A lot of our proxy callback functionality is partially duplicated in PathTimeRunner
-export let atomicObjectSymbol = Symbol.for("atomicObject");
-export function atomicObjectWrite<T>(obj: T): T {
-    if (canHaveChildren(obj) && Object.isExtensible(obj)) {
-        (obj as any)[atomicObjectSymbol] = true;
-    }
-    return recursiveFreeze(obj);
-}
-export function atomicCloneWrite<T>(obj: T): T {
-    return atomicObjectWrite(deepCloneJSON(obj));
-}
-export function atomicObjectWriteNoFreeze<T>(obj: T): T {
-    if (canHaveChildren(obj) && Object.isExtensible(obj)) {
-        (obj as any)[atomicObjectSymbol] = true;
-    }
-    return obj;
-}
-const readNoProxy = Symbol.for("readNoProxy");
-// Specifies we are reading this object, and not any children of it
-export function atomicObjectRead<T>(obj: T): T {
-    if (!isValueProxy(obj)) return obj;
-    return (obj as any)[readNoProxy];
-}
-export const atomic = atomicObjectRead;
-(globalThis as any).atomic = atomic;
-
-export function doUnatomicWrites<T>(callback: () => T): T {
-    return doProxyOptions({ atomicWrites: false }, callback);
-}
-export function doAtomicWrites<T>(callback: () => T): T {
-    return doProxyOptions({ atomicWrites: true }, callback);
-}
-
-const rawRead = Symbol.for("rawRead");
-/** Reads the raw value, which includes transparent values.
- *      - Basically just useful for testing if an object exists in a lookup, in which case
- *          specialObjectWriteValue will be returned for the object.
- *      - NEVER returns a proxy, always a real object (which might be undefined, or an object).
- */
-export function atomicRaw<T>(obj: T): T {
-    if (!isValueProxy(obj)) return obj;
-    return (obj as any)[rawRead];
-}
-
-export function doProxyOptions<T>(options: Partial<WatcherOptions<any>>, callback: () => T): T {
-    let watcher = proxyWatcher.getTriggeredWatcher();
-    let prev = watcher.options;
-    watcher.options = { ...watcher.options, ...options };
-    try {
-        return callback();
-    } finally {
-        watcher.options = prev;
-    }
-}
-
-// HACK: A special value which acts like undefined, EXCEPT when using Object.keys(). The reason it can't
-//  be undefined, is that undefined values are removed by garbage collection, and this has to stick around!
-//  - Is automatically set in the parents paths of object writes, so Object.keys() works.
-//      (Which makes garbage collection a lot harder, but... not impossible, and Object.keys() is so important
-//          that it is okay).
-//  - Due to permissions rejecting root writes, BUT, the ease of this value getting nito relatively root paths
-//      (although hopefully not THE root), reading this counts as a "readIsUndefined"
-//      NOTE: Yes, this does technically mean you depend on the first value to write to an object.
-//          And so, if the first write is rejected, the lock becomes rejected, even though
-//          there might be other writes. This is fine, because the first value is the oldest, so
-//          the least likely to be rejected, and if it is... FunctionRunner will just rerun
-//          the dependent call, and find the key exists again, and the only difference will
-//          be a bit of lag, and value flicker.
-export const specialObjectWriteValue = "_specialObjectWriteValue_16c4c3bb43f24111976a2681c972f6f4";
-export const specialObjectWriteSymbol = Symbol("specialObjectWriteSymbol");
-// Values that don't add another proxy layer
-export function isTransparentValue(value: unknown) {
-    return (
-        value === undefined
-        || value === specialObjectWriteValue
-    );
-}
-
-export function undeleteFromLookup<T>(lookup: { [key: string]: T }, key: string): void {
-    lookup[key] = {} as any;
-}
-
-const syncedSymbol = Symbol.for("syncedSymbol");
-// HACK: This should probably be somewhere else, but... it is just so useful for PathFunctionRunner...
-/** @deprecated this is not very accurate (it breaks for schema accesses). Only use it for low level places that can't call the more accurate Querysub.isSynced) */
-export function isSynced(obj: unknown): boolean {
-    // If it is a primitive, then it must be synced!
-    if (!canHaveChildren(obj)) return true;
-    if (!isValueProxy(obj)) return true;
-    return !!(obj[syncedSymbol]);
-}
-
-export type PermissionsChecker = {
-    checkPermissions(path: string): { permissionsPath: string; allowed: boolean; };
-};
-
-
-class SyncWatcherTag { }
-
-function isRecursiveMatch(paths: Set<string>, path: string): boolean {
-    if (paths.size === 0) return false;
-    if (paths.has(path)) return true;
-    for (let otherPath of paths) {
-        if (path.includes(otherPath) || otherPath.includes(path)) {
-            return true;
-        }
-    }
-    return false;
-}
-function removeMatches(paths: Set<string>, path: string): void {
-    paths.delete(path);
-    for (let otherPath of paths) {
-        if (path.includes(otherPath) || otherPath.includes(path)) {
-            paths.delete(otherPath);
-        }
-    }
-}
-
-export class PathValueProxyWatcher {
-    public static BREAK_ON_READS = new Set<string>();
-    public static BREAK_ON_WRITES = new Set<string>();
-    public static SET_FUNCTION_WATCH_ON_WRITES = new Set<string>();
-    public static LOG_WRITES_INCLUDES = new Set<string>();
-
-    // getPathStr(ModuleId, FunctionId)
-    public static BREAK_ON_CALL = new Set<string>();
-
-    public static DEBUG = false;
-    /** NOTE: This results in VERY slow performance, and will log A LOT of information. */
-    public static TRACE = false;
-    public static TRACE_WRITES = false;
-    public static TRACE_WATCHERS = new Set<string>();
-
-    public static TRACK_TRIGGERS = false;
-
-    private SHOULD_TRACE(watcher: SyncWatcher) {
-        return PathValueProxyWatcher.DEBUG || PathValueProxyWatcher.TRACE || PathValueProxyWatcher.TRACE_WRITES && watcher.options.canWrite || ClientWatcher.DEBUG_TRIGGERS === "heavy" || PathValueProxyWatcher.TRACE_WATCHERS.size > 0 && Array.from(PathValueProxyWatcher.TRACE_WATCHERS).some(x => watcher.debugName.includes(x));
-    }
-
-    private isUnsyncCheckers = new Set<{ value: number }>();
-
-    public countUnsynced = <T>(checker: { value: number }, code: () => T): T => {
-        this.isUnsyncCheckers.add(checker);
-        try {
-            return code();
-        } finally {
-            this.isUnsyncCheckers.delete(checker);
-        }
-    };
-
-    public getCallbackPathValue = (pathStr: string, syncParentKeys?: "parentKeys"): PathValue | undefined => {
-        const watcher = this.runningWatcher;
-        if (!watcher) {
-            debugger;
-            throw new Error(`Tried to get path "${pathStr}" outside of a watcher function.`);
-        }
-
-        if (watcher.options.noLocks && !pathStr.startsWith(LOCAL_DOMAIN_PATH)) {
-            throw new Error(`Tried to read a non-local path in a "noLocks" watcher, ${watcher.debugName}, path ${pathStr}`);
-        }
-
-        if (watcher.permissionsChecker) {
-            if (!watcher.permissionsChecker.checkPermissions(pathStr).allowed) {
-                if (
-                    !watcher.hasAnyUnsyncedAccesses()
-                    && authorityStorage.DEBUG_hasAnyValues(pathStr)
-                    // HACK: Don't show warnings for some framework paths, because they are filling up the console logs
-                    //  and don't really matter. We could just not request them, but at depth 3 is valid,
-                    //  so we kind of have to request that. And at depth 2, it would require special case code,
-                    //  in a bunch of annoying places.
-                    && (getPathIndex(pathStr, 1) !== "PathFunctionRunner" || getPathDepth(pathStr) > 3)
-                ) {
-                    console.warn(`Denied read access to path "${pathStr}"`);
-                    // console.warn(`${new Date().toLocaleTimeString()} Denied read access to path "${pathStr}"`);
-                    // console.warn(new Error().stack);
-                }
-                // This undefined MIGHT cause issues, but... it also makes it easier to check if
-                //  we have permissions, and more clear if we are denied permissions.
-                return undefined;
-            }
-        }
-
-        if (watcher.options.writeOnly) {
-            return undefined;
-        }
-
-        const currentReadTime = watcher.options.forceReadLatest ? undefined : watcher.currentReadTime;
-
-        let pathValue = authorityStorage.getValueAtTime(pathStr, currentReadTime);
-        if (!watcher.options.noSyncing) {
-            // NOTE: If we have any value, we are always synced (that's what synced means, as if we aren't syncing,
-            //  we delete any values, to prevent stale values from being used).
-            if (!pathValue) {
-                // NOTE: We might not have a value simply due to reading too far back in time,
-                //  so we have to call isSynced just to be sure it is actually unsynced
-                if (!authorityStorage.isSynced(pathStr)) {
-                    for (let checker of this.isUnsyncCheckers) {
-                        checker.value++;
-                    }
-                    watcher.pendingUnsyncedAccesses.add(pathStr);
-                }
-            }
-            if (syncParentKeys) {
-                if (!authorityStorage.isParentSynced(pathStr)) {
-                    watcher.pendingUnsyncedParentAccesses.add(pathStr);
-                }
-            }
-            watcher.pendingWatches.paths.add(pathStr);
-            if (syncParentKeys) {
-                watcher.pendingWatches.parentPaths.add(pathStr);
-            }
-
-            if (!pathValue) {
-                let pendingNullAccesses = watcher.pendingEpochAccesses.get(currentReadTime);
-                if (!pendingNullAccesses) {
-                    pendingNullAccesses = new Set();
-                    watcher.pendingEpochAccesses.set(currentReadTime, pendingNullAccesses);
-                }
-                pendingNullAccesses.add(pathStr);
-                return undefined;
-            } else {
-                let readValues = watcher.pendingAccesses.get(currentReadTime);
-                if (!readValues) {
-                    readValues = new Map();
-                    watcher.pendingAccesses.set(currentReadTime, readValues);
-                }
-                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() || 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)) {
-                const unwatch = () => PathValueProxyWatcher.BREAK_ON_READS.delete(pathStr);
-                debugger;
-                unwatch;
-            }
-        }
-        const watcher = this.runningWatcher;
-        if (!watcher) {
-            debugger;
-            throw new Error(`Tried to get path "${pathStr}" outside of a watcher function.`);
-        }
-
-        // IMPORTANT! If we read a value we wrote, we don't need to incur a watch!
-        // NOTE: If we wrote undefined, then that DOESN'T clobber child values, as it actually
-        //  deletes values, so... it doesn't count as having a value.
-        //  - ALSO, writing undefined allows us to then read child values, which is odd,
-        //      but is the correct behavior.
-        if (watcher.pendingWrites.has(pathStr)) {
-            let pendingValue = watcher.pendingWrites.get(pathStr);
-            let isPendingTransparent = isTransparentValue(pendingValue);
-            if (isPendingTransparent) {
-                if (readTransparent) {
-                    return { value: pendingValue };
-                } else {
-                    return undefined;
-                }
-            } else {
-                return { value: pendingValue };
-            }
-        }
-
-        let pathValue = this.getCallbackPathValue(pathStr, syncParentKeys);
-
-        if (!pathValue || !readTransparent && isTransparentValue(pathValueSerializer.getPathValue(pathValue))) {
-            let schema2 = getMatchingSchema(pathStr);
-            if (schema2) {
-                let atomicObj = Schema2Fncs.isAtomic(schema2.schema, "read", schema2.nestedPath);
-                if (atomicObj) {
-                    return { value: atomicObj.defaultValue };
-                }
-                // Check if the object should be an object. Objects can be read though, if they've
-                //      been initialized as an object (with specialObjectWriteValue). OTHERWISE,
-                //      they require initialization (root.object = {}).
-                if (Schema2Fncs.isObject(schema2.schema, schema2.nestedPath)) {
-                    // IMPORTANT! It MAY seem, like we can just add a special "deleteObjectValue_1f548f4a01cb4c35bc7b559d8dd74c42"
-                    //      sentinel, and use that to delete something (both in proxy, and in gc, so it really recursively deletes it),
-                    //      BUT, that has one major issue. Once that sentinel is truly deleted, the value will evaluate a proxy again,
-                    //      which will cause GC to change the state, which would be a bug. Not to mention accessing not existing
-                    //      keys would return a proxy, which is annoying. So... this is the best approach.
-                    if (pathValueSerializer.getPathValue(pathValue) !== specialObjectWriteValue) {
-                        // Means the key was deleted (`delete lookup[key]`), and so the intention is for this
-                        //      to terminate in undefined.
-                        return { value: undefined };
-                    }
-                }
-            }
-            return undefined;
-        } else {
-            let readValue = pathValueSerializer.getPathValue(pathValue);
-            // Unescape specialObjectWriteValue-like strings
-            if (typeof readValue === "string" && readValue.length > specialObjectWriteValue.length && readValue.startsWith(specialObjectWriteValue)) {
-                readValue = readValue.slice(0, -1);
-            }
-            return { value: readValue };
-        }
-    };
-
-    // We exclude undefined, BUT, we include "null", etc.
-    //  - This differs from javascript, but... due to how deletions work, we can't/don't differentiate between
-    //      a deleted value and undefined, and a lot of things break if deleting a value doesn't remove it from an "in" check!
-    private hasCallback = (pathStr: string): boolean => {
-        let value = this.getCallback(pathStr, undefined, "readTransparent");
-        return value?.value !== undefined;
-    };
-
-    private setCallback = (pathStr: string, value: unknown, inRecursion = false, allowSpecial = false): void => {
-        if (PathValueProxyWatcher.BREAK_ON_WRITES.size > 0 && proxyWatcher.isAllSynced()) {
-            if (isRecursiveMatch(PathValueProxyWatcher.BREAK_ON_WRITES, pathStr)) {
-                let unwatch = () => removeMatches(PathValueProxyWatcher.BREAK_ON_WRITES, pathStr);
-                debugger;
-                unwatch;
-            }
-        }
-
-        if (PathValueProxyWatcher.SET_FUNCTION_WATCH_ON_WRITES.size > 0 && proxyWatcher.isAllSynced()) {
-            if (isRecursiveMatch(PathValueProxyWatcher.SET_FUNCTION_WATCH_ON_WRITES, pathStr)) {
-                let unwatch = () => removeMatches(PathValueProxyWatcher.SET_FUNCTION_WATCH_ON_WRITES, pathStr);
-                PathValueProxyWatcher.BREAK_ON_CALL.add(
-                    getPathStr2(getCurrentCall().ModuleId, getCurrentCall().FunctionId)
-                );
-            }
-        }
-
-        if (PathValueProxyWatcher.LOG_WRITES_INCLUDES.size > 0 && proxyWatcher.isAllSynced()) {
-            if (isRecursiveMatch(PathValueProxyWatcher.LOG_WRITES_INCLUDES, pathStr)) {
-                let unwatch = () => removeMatches(PathValueProxyWatcher.LOG_WRITES_INCLUDES, pathStr);
-                console.log(`Write path "${pathStr}" = ${value}`);
-            }
-        }
-        if (value === specialObjectWriteSymbol) {
-            value = specialObjectWriteValue;
-            allowSpecial = true;
-        }
-
-        // Escape specialObjectWriteValue-like strings
-        //  - Check for .startsWith, so we change all values. If we just added when it was ===, then
-        //      anything that === the escaped value before hand, would get unescaped, even though
-        //      it was never escaped!
-        if (!allowSpecial && typeof value === "string" && value.startsWith(specialObjectWriteValue)) {
-            value += " ";
-        }
-
-        const watcher = this.runningWatcher;
-        if (!watcher) {
-            // Ignore preact paths
-            let lastPart = getLastPathPart(pathStr);
-            if (lastPart.startsWith("__") || lastPart === "type") {
-                return;
-            }
-            debugger;
-            throw new Error(`Tried to set path "${pathStr}" outside of a watcher function.`);
-        }
-        if (!watcher.options.canWrite) {
-            throw new Error(`Tried to write to path "${pathStr}" in watcher (${watcher.debugName}) that has { canWrite: false }`);
-        }
-        if (watcher.options.noLocks && !pathStr.startsWith(LOCAL_DOMAIN_PATH)) {
-            throw new Error(`Tried to write a non-local path in a "noLocks" watcher, ${watcher.debugName}, path ${pathStr}`);
-        }
-
-        if (watcher.permissionsChecker) {
-            if (!watcher.permissionsChecker.checkPermissions(pathStr).allowed) {
-                if (value !== specialObjectWriteValue) {
-                    if (!watcher.hasAnyUnsyncedAccesses()) {
-                        // NOTE: Only throw once we sync all accesses, otherwise this could cause sync cascading, which is bad
-                        // NOTE: We COULD do the same thing for reason... but... it should be equivalent to just NOOP reads. We
-                        //      could NOOP writes as well, but throwing makes development easier (by telling you why your write
-                        //      is doing nothing more loudly than just a console warning).
-                        throw new Error(`Denied write access to path "${pathStr}"`);
-                        //console.warn(red(`Denied write access to path "${pathStr}" (ignoring write and continuing)`));
-                    }
-                }
-                return;
-            }
-        }
-
-        if (
-            !watcher.options.forceEqualWrites
-            && (
-                !canHaveChildren(value)
-                || !(atomicObjectSymbol in value || watcher.options.atomicWrites)
-            )
-        ) {
-            // NOTE: This NOOPs on predicted writes as well. BUT, we also incur a lock, so, it's fine...
-            let existingValue = this.getCallback(pathStr, undefined, "readTransparent");
-            // NOTE: We don't deep compare atomicObjectSymbol, as atomicObjectSymbol is often
-            //      used for exotic values. The user will have to deep compare themselves, if
-            //      they want to avoid the extra write.
-            if (existingValue?.value === value) {
-                return;
-            }
-        }
-
-        // Set parent specialObjectWriteValue values
-        if (
-            !watcher.options.writeOnly
-            // If we are an event write we can't set parent values, otherwise the parents will become
-            //  events, which breaks Object.keys on them (which is almost certainly not intended), because
-            //  event paths can't be watched after a certain time.
-            && !watcher.options.eventWrite
-            && !inRecursion
-            // Deletes shouldn't create parent objects!
-            && value !== undefined
-        ) {
-            if (!watcher.pendingWrites.has(pathStr)) {
-                let parentPathStr = pathStr;
-                let isLocal = pathStr.startsWith(LOCAL_DOMAIN_PATH);
-                let depthToData = isLocal ? 1 : DEPTH_TO_DATA;
-                while (true) {
-                    parentPathStr = getParentPathStr(parentPathStr);
-                    if (getPathDepth(parentPathStr) < depthToData) break;
-                    // We don't need to check all parents, as if any value is set, all parents will
-                    //  likely have their specialObjectWriteValue set, due to a previous run of this function!
-                    if (watcher.pendingWrites.has(parentPathStr)) break;
-                    let parentValue = this.getCallback(parentPathStr, undefined, "readTransparent");
-                    // If we have a value, don't set the object.
-                    //  NOTE: This means if you:
-                    //      x.y.z = 1
-                    //      delete x.y; // (OR, x.y = null)
-                    //      x.y.z = 2
-                    //      Object.keys(x.y) === ["z"]
-                    //  Which is annoying (keys show up for values you accidentally resurrected), but...
-                    //      it is somewhat required, as we don't know if you are trying to readd
-                    //      an object, or accidentally resurrected it!
-                    //      - Really you should use a flag for deletion, which will work 100% of the time,
-                    //          and make life easier for specific undoing, and also eventually... instructed garbage collection.
-                    if (parentValue?.value !== specialObjectWriteValue) {
-                        watcher.pendingWrites.set(parentPathStr, specialObjectWriteValue);
-                    }
-                }
-            }
-        }
-
-        function isAtomicSchema(pathStr: string) {
-            let schema2 = getMatchingSchema(pathStr);
-            if (schema2) {
-                let atomicObj = Schema2Fncs.isAtomic(schema2.schema, "write", schema2.nestedPath);
-                if (atomicObj) {
-                    return true;
-                    // NOTE: We can't skip if the value === default, as the previous value might not be the default,
-                    //  (so the write might change the value).
-                    //  - We could optimize the = undefined case for atomic objects, where the value is already undefined
-                    //      (but we defaulted it), but... it's probably not worth the effort.
-                }
-            }
-        }
-
-        // Destructure the value if it is an object, UNLESS, it specifies that it is atomic.
-        if (canHaveChildren(value) && !(atomicObjectSymbol in value) && !watcher.options.atomicWrites && !isAtomicSchema(pathStr)) {
-            const addWrites = (pathStr: string, value: unknown) => {
-                if (canHaveChildren(value) && !(atomicObjectSymbol in value) && !isAtomicSchema(pathStr)) {
-                    this.setCallback(pathStr, specialObjectWriteValue, true, true);
-                    const keys = getKeys(value);
-                    for (let key of keys) {
-                        if (typeof key !== "string") {
-                            throw new Error(`Cannot have non-string keys in non-atomic (atomicObjectWrite) objects. Key: "${String(key)}" at path "${pathStr}".`);
-                        }
-                        addWrites(appendToPathStr(pathStr, key), value[key]);
-                    }
-                } else {
-                    // NOTE: It is a bit inefficient in terms of computation to call setCallback, BUT, it
-                    //  allows us to automatically run our deduping checks, which saves a lot of unnecessary
-                    //  computation on other nodes (and network bandwidth, etc, etc).
-                    this.setCallback(pathStr, value, true);
-                    //watcher.pendingWrites.set(pathStr, value);
-                }
-            };
-            addWrites(pathStr, value);
-        } else {
-            if (!pathStr.startsWith(LOCAL_DOMAIN_PATH)) {
-                // Copy the value, to ensure any proxy values aren't attempted to be written
-                //      to the database. A bit slower, but... it should be fine. We COULD do this
-                //      later on, but this makes it easier to attribute lag and errors to the original source.
-                //  - If we had a proxy, we WOULD copy it eventually, but we would copy it later,
-                //      which would cause an error, because the reader wouldn't be trackable.
-                value = deepCloneCborx(value);
-            }
-            watcher.pendingWrites.set(pathStr, value);
-        }
-    };
-    /** Syncs keys AND values (as we won't return a key for a value that is undefined). */
-    public getKeys = (pathStr: string): string[] => {
-        if (getPathDepth(pathStr) < MODULE_INDEX) {
-            throw new Error(`Cannot call getKeys on path "${pathStr}" because it is too shallow. Must be at least ${MODULE_INDEX} levels deep.`);
-        }
-
-        const watcher = this.runningWatcher;
-        if (!watcher) {
-            debugger;
-            throw new Error(`Tried to getKeys on path "${pathStr}" outside of a watcher function.`);
-        }
-
-        if (watcher.permissionsChecker) {
-            if (!watcher.permissionsChecker.checkPermissions(pathStr).allowed) {
-                console.warn(`Denied read access to parentPath "${pathStr}"`);
-                return [];
-            }
-            let childPath = appendToPathStr(pathStr, Date.now() + "_" + Math.random());
-            if (!watcher.permissionsChecker.checkPermissions(childPath).allowed) {
-                console.warn(red(`Denied write access to children of parent path "${childPath}"`));
-                return [];
-            }
-        }
-
-        // Using the schema for keys is a MASSIVE optimization, despite the potential drawbacks.
-        //  - It returns all possible keys, even optional keys, which isn't the same as Object.keys()
-        //  - It ignores any keys removed from the schema, which causes JSON.stringify to behave differently
-        // HOWEVER, saving an entire serverside call, which would otherwise require a roundtrip before we could
-        //      access values inside the keys... is unbelievably useful. This reduces latency, which is the hardest
-        //      thing to remove. AND, "noAtomicSchema" can always be used to skip this optimization.
-        let schema2 = getMatchingSchema(pathStr);
-        if (schema2) {
-            let atomicKeys = Schema2Fncs.getKeys(schema2.schema, schema2.nestedPath);
-            if (atomicKeys) {
-                return atomicKeys;
-            }
-        }
-
-        // IMPORTANT: The this.getCallback is what triggers the parent watch!
-        //      We leave it up to getCallback to add the parentPaths watch, to allow Object.keys on values
-        //          that were just written with incurring a parent watch.
-        let pathValue = this.getCallback(pathStr, "parentKeys");
-        if (!isTransparentValue(pathValue?.value)) {
-            return getKeys(pathValue?.value) as string[];
-        }
-
-        let childPaths = authorityStorage.getPathsFromParent(pathStr);
-
-        // We need to also get keys from pendingWrites
-        {
-            let copiedChildPaths: Set<string> | undefined;
-            let pendingWrites = watcher.pendingWrites;
-            for (let childPath of pendingWrites.keys()) {
-                if (childPath.length > pathStr.length && childPath.startsWith(pathStr)) {
-                    if (!copiedChildPaths) {
-                        copiedChildPaths = childPaths = new Set(childPaths);
-                    }
-                    copiedChildPaths.add(childPath);
-                }
-            }
-        }
-
-        let keys = new Set<string>();
-        if (childPaths) {
-            let targetDepth = getPathDepth(pathStr);
-            for (let childPath of childPaths) {
-                let key = getPathIndexAssert(childPath, targetDepth);
-                let childValue = this.getCallback(childPath, undefined, "readTransparent");
-                if (childValue?.value !== undefined) {
-                    keys.add(key);
-                }
-            }
-        }
-
-        let keysArray = Array.from(keys);
-
-        // NOTE: Because getPathsFromParent does not preserve order, we have to sort here to ensure
-        //  we provide a consistent order (which might not be the order the user wants, but at least
-        //  it will always fail if it does fail).
-        keysArray.sort();
-
-        return keysArray;
-    };
-
-    private getSymbol = (pathStr: string, symbol: symbol): { value: unknown } | undefined => {
-        if (symbol === Symbol.toPrimitive) return {
-            value: (hint: string) => {
-                if (hint === "string") return "";
-                if (hint === "number") return 0;
-                // NOTE: Returning 0 as the default makes (x++) work nicely, defaulting values to undefined.
-                //  If they are expecting a string... maybe they should use `${x}`, or... just type check it.
-                return 0;
-            }
-        };
-        if (symbol === Symbol.toStringTag) return { value: () => `[proxy at ${pathStr}]` };
-
-        if (symbol === readNoProxy) {
-            let value = this.getCallback(pathStr)?.value;
-            return { value };
-        }
-
-        if (symbol === syncedSymbol) {
-            return { value: authorityStorage.isSynced(pathStr) };
-        }
-
-        // Proxies should be considered atomic, at least for the purpose of other proxies!
-        //  - This allows proxies to be written to synced state easily (although this will
-        //      cause issues if it isn't local synced state, but... there's not too much
-        //      we can do about that. It should just serialize it, possibly reading values
-        //      which weren't synced. Which isn't so bad, as if they start trying to create
-        //      object graphs in synced state they are going to immediately run into issues
-        //      anyways).
-        if (symbol === atomicObjectSymbol) return { value: true };
-
-        if (symbol === rawRead) {
-            return { value: this.getCallback(pathStr, undefined, "readTransparent")?.value };
-        }
-
-        return { value: undefined };
-    };
-
-    private proxy = createPathValueProxy({
-        getCallback: this.getCallback,
-        hasCallback: this.hasCallback,
-        setCallback: this.setCallback,
-        getKeys: this.getKeys,
-        getSymbol: this.getSymbol,
-    });
-
-    private runningWatcher: SyncWatcher | undefined;
-
-    // NOTE: We can't support promises until we are able to run the function on another
-    //  thread (at which point we can ensure there is no parallel function running).
-    public createWatcher<Result = void>(
-        options: WatcherOptions<Result>
-    ): SyncWatcher {
-        if (isAsyncFunction(options.watchFunction)) {
-            throw new Error(`A watcher function cannot be async, it must be synchronous. You probably did Querysub.commitAsync(async () => {}). Just remove the async, and do Querysub.commit(() => {}). The caller will be called again whenever the data you access changes, And if you are running this to return a result, it will be rerun until all the data you want is synchronized. Watch function: ${options.watchFunction.toString()}`);
-        }
-        // NOTE: Setting an order is needed for rendering, so parents render before children. I believe
-        //  it is generally what we want, so event triggering is consistent, and fits with any tree based
-        //  watching system. If this causes problems we COULD remove it from here and have just qreact.tsx set it.
-        if (options.order === undefined) {
-            options.order = nextOrderSeqNum++;
-        }
-
-        // Unwrap nested immediate calls to be as close to a naked call as possible. The watcher never becomes
-        //  the current watcher, and is immediately disposed. We only create SyncWatcher to return it, otherwise
-        //  callers would need to handle a variable return type, which is annoying.
-        //  - This means any writes are attributed to the existing call, which... is fine, if the caller wants
-        //      to disconnect the call from the existing watcher, they should use `Promise.resolve().finally(...)`.
-        // NOTE: We check for runImmediately as we still want to be able to create watchers in
-        //  reaction to trigger of other watchers.
-        if (this.runningWatcher && (options.runImmediately || this.runningWatcher.options.inlineNestedWatchers)) {
-            // TODO: We COULD change our dispose out and change it back, if we find
-            //  we often want to mutate shallow props of nested watchers.
-            const outerWatcher = {
-                ...this.runningWatcher,
-                // Let them use the watcher, EXCEPT, don't let them dispose it,
-                //  as that would dispose the outer watcher as well
-                dispose: () => { },
-            };
-            if (!this.runningWatcher.options.canWrite && options.canWrite) {
-                debugger;
-                throw new Error(`Cannot run a canWrite nested watcher inside of a watcher that can't. Either explicitly specify canWrite = true in outer watcher, canWrite = false in the inner watcher, or disconnect it with Promise.resolve().finally(...)`);
-            }
-            // NOTE: Nested watchers are fine. We need to apply the nested options
-            //  (some of which will be ignroed), but otherwise, all of the watchers
-            //  will be collapsed to a single watcher, making it fairly efficient.
-            let { watchFunction, ...mostOptions } = options;
-            doProxyOptions(mostOptions, () => {
-                try {
-                    let result = authorityStorage.temporaryOverride(options.overrides, () =>
-                        options.watchFunction()
-                    );
-                    // Clone, otherwise proxies get out of the watcher, which can result in accesses outside
-                    //  of a synced watcher.
-                    if (!options.allowProxyResults) {
-                        result = deepCloneCborx(result);
-                    } else {
-                        result = atomicObjectRead(result);
-                    }
-                    options.onResultUpdated?.({ result }, undefined, outerWatcher);
-                } catch (e: any) {
-                    options.onResultUpdated?.({ error: e.stack }, undefined, outerWatcher);
-                }
-            });
-            return outerWatcher;
-        }
-
-        const self = this;
-        if (options.runAtTime) {
-            // 80% of our real max range, so calls with a runAtTime close to our limit have a bit of breathing room to run
-            let runLeeway = MAX_ACCEPTED_CHANGE_AGE * 0.8;
-            let runCutoffTime = Date.now() - runLeeway;
-            if (options.runAtTime && options.runAtTime.time < runCutoffTime) {
-                let message = `MAX_CHANGE_AGE_EXCEEDED! Cannot run watcher ${options.debugName} at time ${options.runAtTime.time} because it is older than the cutOff time of ${runCutoffTime}. Writing this far in the past would break things, and might be rejected by other authorities due to being too old.`;
-                console.error(red(message));
-                // NOTE: We could also adjust the to be more recent, to allow it to be commited anyway,
-                //  in a slightly different state than originally expected.
-                throw new Error(message);
-            }
-        }
-
-        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 = {
-            seqNum: nextSeqNum++,
-            debugName,
-            dispose: () => { },
-            disposed: false,
-            onInnerDisposed: [],
-            onAfterTriggered: [],
-            explicitlyTrigger: () => { },
-            hasAnyUnsyncedAccesses: () => false,
-            currentReadTime: options.runAtTime,
-            nextWriteTime: undefined,
-            setCurrentReadTime: null as any,
-            pendingAccesses: new Map(),
-            pendingEpochAccesses: new Map(),
-            triggeredByChanges: undefined,
-            pendingWrites: new Map(),
-            pendingEventWrites: new Set(),
-            pendingCalls: [],
-            pendingWatches: {
-                paths: new Set(),
-                parentPaths: new Set(),
-            },
-            lastWatches: {
-                paths: new Set(),
-                parentPaths: new Set(),
-            },
-
-            pendingUnsyncedAccesses: new Set(),
-            pendingUnsyncedParentAccesses: new Set(),
-            lastUnsyncedAccesses: new Set(),
-            lastUnsyncedParentAccesses: new Set(),
-
-            specialPromiseUnsynced: false,
-            lastSpecialPromiseUnsynced: false,
-
-            options,
-            consecutiveErrors: 0,
-            countSinceLastFullSync: 0,
-            lastEvalTime: 0,
-            lastSyncTime: now,
-            startTime: now,
-            syncRunCount: 0,
-            tag: new SyncWatcherTag(),
-
-            hackHistory: [],
-            createTime: getTimeUnique(),
-        };
-        addToProxyOrder(watcher);
-        const SHOULD_TRACE = this.SHOULD_TRACE(watcher);
-        const proxy = this.proxy;
-
-        if (options.overrides && !options.dryRun) {
-            // If you override values, and want to watch values... how does that even work? And what about
-            //      writes? You can't depend on an override, so... what would we do?
-            throw new Error(`overrides without dryRun is not presently supported`);
-        }
-
-        watcher.dispose = dispose;
-        this.allWatchers.add(watcher);
-
-        let baseFunction = options.watchFunction;
-        baseFunction = measureWrap(baseFunction, watcher.debugName);
-        {
-            let base = baseFunction;
-            baseFunction = (...args: unknown[]) => {
-                let time = Date.now();
-                try {
-                    return (base as any)(...args);
-                } finally {
-                    onTimeProfile("Performance|Watcher", time);
-                }
-            };
-        }
-
-        watcher.setCurrentReadTime = (time, code) => {
-            let prev = watcher.currentReadTime;
-            watcher.currentReadTime = time;
-            try {
-                return code();
-            } finally {
-                watcher.currentReadTime = prev;
-            }
-        };
-        watcher.hasAnyUnsyncedAccesses = () => {
-            if (watcher.options.waitForIncompleteTransactions) {
-                waitIfReceivedIncompleteTransaction();
-            }
-            return (
-                watcher.pendingUnsyncedAccesses.size > 0
-                || watcher.pendingUnsyncedParentAccesses.size > 0
-                || watcher.specialPromiseUnsynced
-                || isProxyBlockedByOrder(watcher)
-            );
-        };
-        const getReadyToCommit = () => {
-            if (watcher.options.commitAllRuns) {
-                return true;
-            }
-            return (
-                watcher.lastUnsyncedAccesses.size === 0
-                && watcher.lastUnsyncedParentAccesses.size === 0
-                && !watcher.lastSpecialPromiseUnsynced
-                && !isProxyBlockedByOrder(watcher)
-            );
-        };
-        function afterTrigger() {
-            for (let i = 0; i < 10; i++) {
-                let callbacks = watcher.onAfterTriggered;
-                watcher.onAfterTriggered = [];
-                for (let callback of callbacks) {
-                    logErrors(((async () => { await callback(); }))());
-                }
-                if (watcher.onAfterTriggered.length === 0) break;
-            }
-            if (watcher.onAfterTriggered.length > 0) {
-                console.warn(`Watcher ${watcher.debugName} keeps adding after trigger callbacks during after trigger. We reached our iteration limit 
-                    and will be ignoring triggers remaining triggers.`);
-            }
-        }
-
-        function dispose() {
-            if (watcher.disposed) return;
-            watcher.disposed = true;
-            clientWatcher.unwatch(trigger);
-            self.allWatchers.delete(watcher);
-
-            // NOTE: We trigger next before onInnerDisposed, as onInnerDispose often run more commits, and if we proxy block it causes proxies to run twice.
-            // TODO: Is this guaranteed to be called all the time? What about nested proxy watchers?
-            void finishProxyAndTriggerNext(watcher);
-
-            for (let i = 0; i < 10; i++) {
-                let disposeCallbacks = watcher.onInnerDisposed;
-                watcher.onInnerDisposed = [];
-                for (let callback of disposeCallbacks) {
-                    logErrors(((async () => { await callback(); }))());
-                }
-                if (watcher.onInnerDisposed.length === 0) break;
-            }
-            if (watcher.onInnerDisposed.length > 0) {
-                console.warn(`Watcher ${watcher.debugName} keeps adding inner disposed callbacks during dispose. We reached our iteration limit 
-                    and will be ignoring dispose callbacks remaining dispose callbacks.`);
-            }
-
-            self.allWatchersLookup.delete(trigger);
-        }
-        function runWatcher() {
-            watcher.pendingWrites.clear();
-            watcher.pendingEventWrites.clear();
-            watcher.pendingCalls = [];
-            // NOTE: We have to make new sets here, because these Sets are reused for lastWatches, which makes
-            //  it's way into clientWatcher, without changing. So if we just clear it, we can break clientWatcher.
-            watcher.pendingWatches.paths = new Set();
-            watcher.pendingWatches.parentPaths = new Set();
-            watcher.pendingUnsyncedAccesses.clear();
-            watcher.pendingUnsyncedParentAccesses.clear();
-
-            watcher.pendingAccesses.clear();
-            watcher.pendingEpochAccesses.clear();
-            // 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.
-            //      - Even using Date.now() is not far enough in the future, as we might be given data a bit before Date.now() due to clock
-            //      differences. And we can't just set it arbitrarily into the future, as then we will be writing
-            //      in the future, which would cause us to become rejected on writes that happen after our real
-            //      time (but after our given time).
-            watcher.nextWriteTime = watcher.options.runAtTime;
-            // Ensure nextWriteTime is a unique time every run, in case we were rerun due to a rejection (unless it is a dryRun,
-            //  in which case the writes won't be committed, so they don't need to be unique).
-
-            // NOTE: We prefer to not set the time, as if our clock is at all in the past (or other clocks are in the future),
-            //  then when we receive a value we will ignore it.
-            if (!watcher.options.dryRun && watcher.nextWriteTime) {
-                watcher.nextWriteTime = clientWatcher.getFreeWriteTime(watcher.nextWriteTime);
-            }
-
-            // The read time equals the write time, so our locks use the same time as our write time, and
-            //  therefore lock the actual state we used.
-            watcher.currentReadTime = watcher.nextWriteTime;
-
-            watcher.permissionsChecker = options.getPermissionsCheck?.();
-
-            let result: { result: Result } | { error: string };
-            try {
-                let rawResult: Result;
-                const handling = watcher.options.nestedCalls;
-                let curFunction = baseFunction;
-                if (handling === "inline") {
-                    curFunction = () => inlineNestedCalls(baseFunction);
-                }
-                rawResult = interceptCalls({
-                    onCall(call, metadata) {
-                        if (PathValueProxyWatcher.BREAK_ON_CALL.size > 0 && !watcher.hasAnyUnsyncedAccesses()) {
-                            let hash = getPathStr2(call.ModuleId, call.FunctionId);
-                            if (PathValueProxyWatcher.BREAK_ON_CALL.has(hash)) {
-                                const unwatch = () => removeMatches(PathValueProxyWatcher.BREAK_ON_CALL, hash);
-                                debugger;
-                                unwatch;
-                            }
-                        }
-                        if (!watcher.options.canWrite) {
-                            throw new Error(`Cannot call a synced function in a watcher which does not have write permissions. If you want to call a function, you must also have write permissions.`);
-                        }
-                        if (handling === "throw") {
-                            // TODO: Support making inline calls, which is useful as it will check permissions. Although, it can
-                            //  easily be slow, and adds a lot of complexity, so... maybe not... maybe always force the app
-                            //  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) {
-                            // 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") {
-                        } else if (handling === "inline") {
-                            throw new Error(`inlineNestedCalls should have prevented this call from being passed to us`);
-                        } else {
-                            let unhandled: never = handling;
-                            throw new Error(`Invalid handling type ${handling}`);
-                        }
-                    },
-                    code() {
-                        return authorityStorage.temporaryOverride(options.overrides, () =>
-                            runCodeWithDatabase(proxy, baseFunction)
-                        );
-                    },
-                }) as Result;
-
-                // NOTE: Deep clone non-local paths. It's too confusing for a partial object to be returned. Any issues caused by
-                //  this (aka, returning the entire database), would also happen if we manually added deep clones before
-                //  we returned values (and both should be throttled at a framework level so we don't break the database).
-                //  - For local paths there is a risk that there are functions
-                if (!options.allowProxyResults) {
-                    try {
-                        rawResult = deepCloneCborx(rawResult);
-                    } catch {
-                        // Unfortunately, cborx throws on functions.
-                        // TODO: Use a recursive clone technique that doesn't throw on functions
-                        rawResult = atomicObjectRead(rawResult);
-                    }
-                } else {
-                    rawResult = atomicObjectRead(rawResult);
-                }
-
-                result = { result: rawResult };
-                watcher.consecutiveErrors = 0;
-            } catch (e: any) {
-                watcher.consecutiveErrors++;
-                if (watcher.consecutiveErrors > 10) {
-                    console.error(`Watch callback is failing a lot ${watcher.debugName} (${watcher.consecutiveErrors} times). It is possible you are throwing in a loop on unsynced values. Instead for all the values you want to check, then loop over them, otherwise syncing could take forever.`);
-                    console.error(e);
-                }
-                result = { error: e.stack };
-            } finally {
-                afterTrigger();
-                // Set the checker to undefined, so we don't accidentally use it again,
-                //  as it will throw if we try to use it after any asynchronous delay.
-                watcher.permissionsChecker = undefined;
-            }
-
-
-            let anyUnsynced = watcher.hasAnyUnsyncedAccesses();
-
-            watcher.lastUnsyncedAccesses = watcher.pendingUnsyncedAccesses;
-            watcher.lastUnsyncedParentAccesses = watcher.pendingUnsyncedParentAccesses;
-            watcher.lastSpecialPromiseUnsynced = watcher.specialPromiseUnsynced;
-
-            // 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 || {
-                        startTime: Date.now(),
-                        unsyncedPaths: new Set(),
-                        unsyncedStages: [],
-                    };
-                    let newPaths: string[] = [];
-                    let set = watcher.logSyncTimings.unsyncedPaths;
-                    function addPath(path: string) {
-                        if (set.has(path)) return;
-                        set.add(path);
-                        newPaths.push(path);
-                    }
-                    for (let path of watcher.lastUnsyncedAccesses) {
-                        addPath(path);
-                    }
-                    for (let path of watcher.lastUnsyncedParentAccesses) {
-                        addPath(path);
-                    }
-                    if (newPaths.length > 0) {
-                        watcher.logSyncTimings.unsyncedStages.push({
-                            paths: newPaths,
-                            time: Date.now(),
-                        });
-                    }
-                } else {
-                    if (watcher.logSyncTimings) {
-                        let now = Date.now();
-                        console.groupCollapsed(`${watcher.debugName} synced in ${formatTime(now - watcher.logSyncTimings.startTime)}`);
-                        // Log the stages
-                        let stages = watcher.logSyncTimings.unsyncedStages;
-                        for (let i = 0; i < stages.length; i++) {
-                            let nextTime = stages[i + 1]?.time || now;
-                            let stage = stages[i];
-                            console.groupCollapsed(`${formatTime(nextTime - stage.time)}`);
-                            for (let path of stage.paths) {
-                                console.log(path);
-                            }
-                            console.groupEnd();
-                        }
-                        console.groupEnd();
-                        watcher.logSyncTimings = undefined;
-                    }
-                }
-            }
-
-            if (!watcher.options.static) {
-                if (!anyUnsynced) {
-                    watcher.countSinceLastFullSync = 0;
-                    watcher.lastSyncTime = Date.now();
-                    watcher.syncRunCount++;
-                } else {
-                    if (watcher.countSinceLastFullSync === 0) {
-                        let syncRunCount = watcher.syncRunCount;
-                        setTimeout(() => {
-                            if (watcher.syncRunCount !== syncRunCount) return;
-                            if (watcher.disposed) return;
-                            let remainingUnsynced = Array.from(watcher.lastUnsyncedAccesses).filter(x => !authorityStorage.isSynced(x));
-                            let remainingUnsyncedParent = Array.from(watcher.lastUnsyncedParentAccesses).filter(x => !authorityStorage.isParentSynced(x));
-                            console.warn(red(`Did not sync ${watcher.debugName} after 30 seconds. Either we had a lot synchronous block, or we will never received the values we are waiting for.`), remainingUnsynced, remainingUnsyncedParent, watcher.options.watchFunction);
-                        }, 30 * 1000);
-                        setTimeout(() => {
-                            if (watcher.syncRunCount !== syncRunCount) return;
-                            if (watcher.disposed) return;
-
-                            // IMPORTANT! Any of these can be also caused by high synchronous lag!
-                            //  - If this becomes a serious concern, we could add a watch loop for this, which
-                            //      tries to run every second, recording how far it misses the target time by,
-                            //      and then uses that (plus any outstanding missed time) to determine how much lag
-                            //      we have had since this watcher last synced. If it is > 50% of the time...
-                            //      then synchronous lag is the issue.
-
-                            let reallyUnsyncedAccesses = Array.from(watcher.lastUnsyncedAccesses).filter(x => !authorityStorage.isSynced(x));
-                            let reallyUnsyncedParentAccesses = Array.from(watcher.lastUnsyncedParentAccesses).filter(x => !authorityStorage.isParentSynced(x));
-
-                            if (reallyUnsyncedAccesses.length !== 0 || reallyUnsyncedParentAccesses.length !== 0) {
-                                let notWatchingUnsynced = reallyUnsyncedAccesses.filter(x => !remoteWatcher.debugIsWatchingPath(x));
-                                let notWatchingUnsyncedParent = reallyUnsyncedParentAccesses.filter(x => !remoteWatcher.debugIsWatchingPath(x));
-                                if (notWatchingUnsynced.length !== 0 || notWatchingUnsyncedParent.length !== 0) {
-                                    console.error((`${red("WATCHER FAILED TO SYNC")} ${watcher.debugName} ${magenta("NOT REMOTE WATCHING REQUIRED PATHS")}. This means our sync or unsync (likely unsync) logic is broken, in remoteWatcher/clientWatcher. OR, there were no read nodes when we tried to sync (we don't handle missing read nodes correctly at the moment)`), notWatchingUnsynced, notWatchingUnsyncedParent, watcher.options.watchFunction);
-                                    debugbreak(2);
-                                    debugger;
-                                } else {
-                                    console.error((`${red("WATCHER FAILED TO SYNC")} ${watcher.debugName} ${magenta("DID NOT RECEIVE PATH VALUES")}. This means PathValueServer is not responding to watches, either to specific paths, or for all paths`), reallyUnsyncedAccesses, reallyUnsyncedParentAccesses, watcher.options.watchFunction);
-                                    // debugbreak(2);
-                                    // debugger;
-                                }
-                            } else if (watcher.lastSpecialPromiseUnsynced) {
-                                console.warn((`${yellow("WATCHER SLOW TO SYNC")} ${watcher.debugName} ${magenta("DEPENDENT PROMISE NEVER RESOLVED")}. This promise might resolve, but it probably won't. Slow promises should be detached from the watcher system and use multiple watchers/writes, instead of blocking on a promise.`), watcher.lastSpecialPromiseUnsyncedReason, watcher.options.watchFunction);
-                                debugbreak(2);
-                                debugger;
-                            } else {
-                                console.error((`${red("WATCHER FAILED TO SYNC")} ${watcher.debugName} ${magenta("DID NOT TRIGGER WATCHER")}. This means either ProxyWatcher is broken (and isn't triggering when it should, or isn't watching when it should), or ClientWatcher/PathWatcher are broken and are not properly informing callers of watchers.`), watcher.lastUnsyncedAccesses, watcher.lastUnsyncedParentAccesses, watcher.options.watchFunction);
-                                debugbreak(2);
-                                debugger;
-                            }
-                        }, 60000);
-                    }
-                    watcher.countSinceLastFullSync++;
-                    if (watcher.countSinceLastFullSync > 10) {
-                        require("debugbreak")(2);
-                        debugger;
-                        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 (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}})`;
-                        console.error(red(errorMessage));
-                        logUnsynced();
-                        result = { error: new Error(errorMessage).stack || "" };
-                        // Force the watches to be equal, so we stop looping
-                        watcher.pendingWatches.paths = new Set(watcher.lastWatches.paths);
-                        watcher.pendingWatches.parentPaths = new Set(watcher.lastWatches.parentPaths);
-                        watcher.syncRunCount++;
-                    }
-                }
-            }
-
-            return result;
-        }
-        function updateWatchers() {
-            watcher.lastWatches = {
-                paths: watcher.pendingWatches.paths,
-                parentPaths: watcher.pendingWatches.parentPaths,
-            };
-
-            // NOTE: I don't see the reason for this. How many watchers do we have that aren't watching anything? 
-            // If nothing is being watched, and nothing was... then don't bother updating the watchers
-            // if (
-            //     !initialTriggerWatch
-            //     && watcher.lastWatches.paths.size === 0 && watcher.lastWatches.parentPaths.size === 0
-            //     && watcher.pendingWatches.paths.size === 0 && watcher.pendingWatches.parentPaths.size === 0
-            // ) return;
-
-            clientWatcher.setWatches({
-                debugName: watcher.debugName,
-                // We don't need to trigger immediately, as we already ran, and if all of our values were synced
-                //  we will have already committed any results.
-                noInitialTrigger: true,
-                paths: watcher.lastWatches.paths,
-                parentPaths: watcher.lastWatches.parentPaths,
-                order: watcher.options.order,
-                orderGroup: watcher.options.orderGroup,
-                callback: trigger,
-                unwatchEventPaths(paths) {
-                    self.unwatchEventPaths(watcher, paths);
-                },
-            });
-        }
-        function commitWrites(): PathValue[] | undefined {
-            if (!options.canWrite) return undefined;
-
-            let setValues: PathValue[] | undefined;
-
-            let prefixes = options.overrideAllowLockDomainsPrefixes || getAllowedLockDomainsPrefixes();
-            // This consumes our write time, as once we write, we can't reuse writeTimes!
-            //  (If we do, it breaks dependencies).
-            let writeTime = watcher.nextWriteTime;
-            watcher.nextWriteTime = undefined;
-            if (!writeTime) {
-                writeTime = getNextTime();
-            }
-
-            if (
-                !watcher.options.hasSideEffects
-                && watcher.pendingWrites.size === 0
-                && watcher.pendingCalls.length === 0
-            ) {
-                wastedEvaluations++;
-            }
-            evaluations++;
-
-            if (watcher.pendingWrites.size > 0) {
-                let locks: ReadLock[] = [];
-                let historyBasedReads = false;
-                for (let time of watcher.pendingAccesses.keys()) {
-                    if (time === undefined) continue;
-                    // If we're reading from a specific time, and it isn't just our write time, then we're reading in the past.
-                    if (compareTime(time, writeTime) !== 0) {
-                        historyBasedReads = true;
-                        break;
-                    }
-                }
-
-                if (!watcher.options.noLocks && !watcher.options.unsafeNoLocks) {
-                    for (let [readTime, values] of watcher.pendingAccesses) {
-                        if (!readTime) {
-                            readTime = writeTime;
-                        }
-                        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;
-                            }
-                            if (!prefixes.some(x => value.path.startsWith(x))) continue;
-                            let newReadCheck = !!value.isTransparent;
-                            if (value.canGCValue && !value.isTransparent) {
-                                console.error(`Value is GCable, but not transparent. We likely forgot to set isTransparent when setting canGCValue. Path ${value.path}, value: ${String(pathValueSerializer.getPathValue(value))}`);
-                                debugbreak(2);
-                                debugger;
-                            }
-                            locks.push({
-                                path: value.path,
-                                startTime: value.time,
-                                endTime: readTime,
-                                readIsTransparent: newReadCheck,
-                            });
-                        }
-                    }
-                    for (let [readTime, paths] of watcher.pendingEpochAccesses) {
-                        if (!readTime) {
-                            readTime = writeTime;
-                        }
-                        for (let path of paths) {
-                            if (!prefixes.some(x => path.startsWith(x))) continue;
-                            locks.push({
-                                path,
-                                startTime: epochTime,
-                                endTime: readTime,
-                                readIsTransparent: true,
-                            });
-                        }
-                    }
-                }
-
-                {
-                    // Ensure our write time isn't before any of our reads (as long as we aren't running
-                    //  at a specific time).
-                    //  - We might want an option to disable this behavior? Although, I'm not sure how we would
-                    //      run in the present, but intentionally want to write in the past? This usually only
-                    //      happens if we intentionally run in the past (in which case writeTime will be set,
-                    //      so this if statement wouldn't run anyways).
-                    let fixedWriteTime = writeTime;
-                    for (let lock of locks) {
-                        if (compareTime(lock.endTime, fixedWriteTime) > 0) {
-                            fixedWriteTime = {
-                                time: addEpsilons(lock.endTime.time, 1),
-                                version: 0,
-                                creatorId: getCreatorId(),
-                            };
-                        }
-                    }
-                    if (fixedWriteTime !== writeTime) {
-                        let prevWriteTime = writeTime;
-                        writeTime = fixedWriteTime;
-                        for (let lock of locks) {
-                            if (lock.endTime === prevWriteTime) {
-                                lock.endTime = writeTime;
-                            }
-                        }
-                    }
-                }
-
-                let forcedUndefinedWrites = new Set<string>();
-                for (let [path, value] of watcher.pendingWrites) {
-                    if (value === specialObjectWriteValue) {
-                        forcedUndefinedWrites.add(path);
-                    }
-                }
-
-                let maxLocks = watcher.options.maxLocksOverride || DEFAULT_MAX_LOCKS;
-                if (locks.length > maxLocks) {
-                    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,
-                    writeTime: writeTime,
-                    locks,
-                    noWritePrediction: options.doNotStoreWritesAsPredictions,
-                    eventWrite: options.eventWrite,
-                    dryRun: options.dryRun,
-                    forcedUndefinedWrites,
-                    source: options.source,
-                    historyBasedReads,
-                });
-            }
-
-            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();
-                    call.fromProxy = watcher.debugName;
-                    logErrors(runCall(call, metadata));
-                    watcher.options.onCallCommit?.(call, metadata);
-                }
-            });
-
-            return setValues;
-
-        }
-        const hasUnsyncedBefore = measureWrap(function proxyWatchHasUnsyncedBefore() {
-            if (watcher.options.commitAllRuns) return 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)) {
-                    return true;
-                }
-            }
-            for (let path of watcher.lastUnsyncedParentAccesses) {
-                if (!authorityStorage.isParentSynced(path)) {
-                    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 false;
-        });
-        function logUnsynced() {
-            let anyLogged = false;
-            for (let path of watcher.lastUnsyncedAccesses) {
-                if (!authorityStorage.isSynced(path)) {
-                    console.log(yellow(`    Waiting for ${path}`));
-                    anyLogged = true;
-                }
-            }
-            for (let path of watcher.lastUnsyncedParentAccesses) {
-                if (!authorityStorage.isParentSynced(path)) {
-                    console.log(yellow(`    Waiting for parent ${path}`));
-                    anyLogged = true;
-                }
-            }
-            // NOTE: We don't log for promises, as they are not checked in hasUnsyncedBefore
-            return anyLogged;
-        }
-
-
-        let trigger = (changed?: WatchSpecData) => {
-            let time = Date.now();
-
-            if (this.runningWatcher) {
-                throw new Error(`Tried to trigger a nested watcher. This likely means explicitlyTrigger was called inside a callback. Instead, use a watched synced sequenceNumber, accessed in the first line of the target watcher, which is incremented when you want to re-evaluate it. Attempted nested watcher ${watcher.debugName}, triggered by ${this.runningWatcher.debugName}`);
-            }
-            if (watcher.disposed) {
-                return;
-            }
-
-            // Merge triggers. We keep triggers if a callback fails to rerun due to unsynced values. This is essential, as it allows
-            //  callbacks to always receive every changed value, which we rely on to maintain delta based dependencies.
-            {
-                if (changed && (PathValueProxyWatcher.TRACK_TRIGGERS || ClientWatcher.DEBUG_TRIGGERS || options.trackTriggers)) {
-                    if (watcher.triggeredByChanges) {
-                        for (let path of changed.paths) {
-                            watcher.triggeredByChanges.paths.add(path);
-                        }
-                        for (let parentPath of changed.newParentsSynced) {
-                            watcher.triggeredByChanges.newParentsSynced.add(parentPath);
-                        }
-                        if (changed.pathSources) {
-                            if (watcher.triggeredByChanges.pathSources) {
-                                for (let value of changed.pathSources) {
-                                    watcher.triggeredByChanges.pathSources.add(value);
-                                }
-                            } else {
-                                watcher.triggeredByChanges.pathSources = new Set(changed.pathSources);
-                            }
-                        }
-                        if (changed.extraReasons) {
-                            watcher.triggeredByChanges.extraReasons = [
-                                ...watcher.triggeredByChanges.extraReasons || [],
-                                ...changed.extraReasons
-                            ];
-                        }
-                    } else {
-                        watcher.triggeredByChanges = changed;
-                    }
-                }
-            }
-
-            triggerCount++;
-            let dropInsteadOfDelay = options.runImmediately || options.temporary;
-
-            const runOncePerPaint = options.runOncePerPaint;
-
-            if (runOncePerPaint) {
-                if (pausedUntilNextPaint.has(runOncePerPaint)) {
-                    let prevValue = pausedUntilNextPaint.get(runOncePerPaint);
-                    if (dropInsteadOfDelay) {
-                        triggersDropped++;
-                    } else if (prevValue !== PAINT_NOOP_FUNCTION) {
-                        // If the previous value was a NOOP, we aren't dropping the function, we are just delaying it
-                        triggersDropped++;
-                    }
-                    pausedUntilNextPaint.set(runOncePerPaint, () => {
-                        // Use dropInsteadOfDelay as late as possible, so it is set by the latest call,
-                        //  instead of the first call.
-                        if (dropInsteadOfDelay) return;
-                        watcher.explicitlyTrigger();
-                    });
-                    return;
-                }
-
-                // Set NOOP function just as a placeholder, to block future calls (until the next paint)
-                pausedUntilNextPaint.set(runOncePerPaint, PAINT_NOOP_FUNCTION);
-                void onNextPaint().finally(() => {
-                    let fnc = pausedUntilNextPaint.get(runOncePerPaint);
-                    if (!fnc) return;
-                    pausedUntilNextPaint.delete(runOncePerPaint);
-                    fnc();
-                });
-            }
-
-            if (!options.runImmediately && !options.allowUnsyncedReads && hasUnsyncedBefore()) {
-                if (SHOULD_TRACE) {
-                    console.log(yellow(`Skipping trigger due to unsynced watchers. ${watcher.debugName} at ${time}`), watcher.triggeredByChanges);
-                    if (!logUnsynced()) {
-                        debugbreak(2);
-                        debugger;
-                    }
-                }
-                // NOTE: When we sync the values, we will automatically be triggered, so we don't need to
-                //  setup a trigger here.
-                return;
-            }
-
-            // NOTE: We don't log the trigger evaluation starting, as that should really be logged inside of ClientWatcher,
-            //      as a result of ClientWatcher.DEBUG_TRIGGERS (except for runImmediate).
-            if (options.runImmediately) {
-                if (SHOULD_TRACE) {
-                    console.log(`${green("INITIAL TRIGGER")} ${watcher.debugName}`, watcher.triggeredByChanges);
-                }
-            }
-
-            watcher.lastEvalTime = Date.now();
-
-            // Do as little as possible while runningWatcher is true. This allows callbacks, etc, to create
-            //  new watchers without having to juggle .runningWatcher.
-            let result: { result: Result } | { error: string } | undefined;
-            try {
-                this.runningWatcher = watcher;
-                result = runWatcher();
-            } finally {
-                this.runningWatcher = undefined;
-            }
-
-            const nonLooping = options.runImmediately || options.allowUnsyncedReads;
-
-            const readyToCommit = (
-                nonLooping || getReadyToCommit()
-            );
-
-            if (!nonLooping) {
-                if (readyToCommit) {
-                    harvestableReadyLoopCount++;
-                } else {
-                    harvestableWaitingLoopCount++;
-                }
-            }
-
-            // Commit writes BEFORE we watch. This prevents us from triggering ourself, in our first watch
-            //  (on subsequent watches ClientWatcher will prevent self watches. It can't for the first
-            //  watch, as it wasn't the triggerer).
-            let values: PathValue[] | undefined;
-            if (readyToCommit) {
-                try {
-                    values = commitWrites();
-                } catch (e: any) {
-                    // setValues might throw, such as if the write time is too far into the past.
-                    result = { error: e.stack };
-                }
-            }
-
-            if (SHOULD_TRACE && "error" in result) {
-                console.log(red(`Error in watcher ${watcher.debugName} at ${time}`), result.error);
-            }
-
-            if (!options.runImmediately) {
-                updateWatchers();
-            }
-
-            if (!readyToCommit) {
-                if (SHOULD_TRACE) {
-                    console.log(yellow(`Skipping trigger commit due to unsynced accesses. ${watcher.debugName} at ${time}`), watcher.triggeredByChanges);
-                    if (watcher.lastSpecialPromiseUnsynced) {
-                        console.log(yellow(`    Waiting for promise`));
-                    }
-                    logUnsynced();
-                }
-                return;
-            }
-
-            if (SHOULD_TRACE) {
-                console.log(green(`Committing ${values?.length || 0} watcher writes ${watcher.debugName} at ${time}`), watcher.triggeredByChanges, watcher.lastUnsyncedAccesses, watcher.lastUnsyncedParentAccesses);
-            }
-
-            // ONLY clear triggeredByChanges when we have a succesful run, otherwise delta based watchers won't work!
-            watcher.triggeredByChanges = undefined;
-            options.onResultUpdated?.(result, values, watcher);
-        };
-        trigger = measureWrap(trigger, `(watcher) ${watcher.debugName}`);
-        watcher.explicitlyTrigger = trigger;
-
-        self.allWatchersLookup.set(trigger, watcher);
-
-        if (options.static) {
-            // Do nothing, this will be explicitly triggered when needed
-        } else if (options.runImmediately) {
-            trigger(undefined);
-            dispose();
-        } else {
-            // Set our watchers
-            updateWatchers();
-            clientWatcher.explicitlyTriggerWatcher(trigger, {
-                synchronous: options.synchronousInit,
-            });
-        }
-        return watcher;
-    }
-
-    /** IMPORTANT! Values written will only show up in direct parent calls.
-     *      This means if you do `data.list[Date.now()].value = value`,
-     *          getKeys(data.list) will NOT have your new key.
-     *      Instead, do writes like this: `data.list[Date.now()] = { value }`,
-     *          or, if the objects are atomic, like this: `data.list[Date.now()] = atomicObjectWrite({ value })`,
-     *          which is move efficient (but the .value cannot be mutated in the future, only clobbered).
-     *      NOTE: For reading values (readOnly), just use `commitFunction`.
-    */
-    public writeOnly<Result = void>(
-        options: Omit<WatcherOptions<Result>, "onResultUpdated" | "onWriteCommitted">
-    ): Result {
-        let result: { result: Result } | { error: string } | undefined;
-        this.createWatcher({
-            forceEqualWrites: true,
-            ...options,
-            writeOnly: true,
-            runImmediately: true,
-            allowUnsyncedReads: true,
-            canWrite: true,
-            temporary: true,
-            onResultUpdated: r => {
-                result = r;
-            }
-        });
-        if (!result) {
-            throw new Error("Expected result to be set");
-        }
-        if ("error" in result) {
-            throw errorify(result.error);
-        }
-        return result.result as Result;
-    }
-
-    public runOnce<Result = void>(
-        options: Omit<WatcherOptions<Result>, "onResultUpdated" | "onWriteCommitted">
-    ): Result {
-        let result: { result: Result } | { error: string } | undefined;
-        let watcher = this.createWatcher({
-            ...options,
-            runImmediately: true,
-            allowUnsyncedReads: true,
-            canWrite: true,
-            temporary: true,
-            onResultUpdated: r => {
-                result = r;
-            }
-        });
-        if (!result) {
-            throw new Error("Expected result to be set");
-        }
-        if ("error" in result) {
-            throw errorify(result.error);
-        }
-        if (watcher.lastUnsyncedAccesses.size > 0 || watcher.lastUnsyncedParentAccesses.size > 0) {
-            //console.warn(`One time watcher run had unsynced accesses after running once. The result will be incomplete. Run with syncing (Querysub.commit) to actually synchronize new values, ${watcher.debugName}`, watcher.options.watchFunction, watcher.lastUnsyncedAccesses, watcher.lastUnsyncedParentAccesses);
-        }
-        return result.result as Result;
-    }
-
-    /** Runs the function until all reads are synced, then disposes the watcher and returns
-     *      - Can be used just with readers, but is most useful for writers (as the
-     *          absolutely soonest we can safely write is when all reads are synced)
-     *      - "writeOnly" is a dangerous version of this, which doesn't wait, and instead
-     *          just writes immediately (but in exchange, it cannot read).
-     *  TODO: Find a way to reuse watchers with different functions. For simple functions this can be
-     *      about 4X faster. It is more difficult if the function has to wait to sync values,
-     *      but we can probably still reuse watchers in some way.
-     *      - The "static" option might help with this.
-     */
-    public async commitFunction<Result = void>(
-        options: Omit<WatcherOptions<Result>, "onResultUpdated" | "onWriteCommitted">,
-        config?: {
-            onWritesCommitted?: (writes: PathValue[]) => void;
-        }
-    ): Promise<Result> {
-        options = {
-            canWrite: true,
-            waitForIncompleteTransactions: true,
-            ...options,
-        };
-
-        if (this.runningWatcher?.options.inlineNestedWatchers) {
-            this.createWatcher(options);
-            return "Nested commitFunctions cannot return values" as any;
-        }
-
-        let onResult!: (result: Result) => void;
-        let onError!: (error: Error) => void;
-        let resultPromise = new Promise<Result>((resolve, reject) => { onResult = resolve; onError = reject; });
-        let anyWrites = false;
-        this.createWatcher({
-            ...options,
-            temporary: true,
-            onResultUpdated: (result, writes, watcher) => {
-                if (writes?.length) {
-                    anyWrites = true;
-                }
-                watcher.dispose();
-                if ("error" in result) {
-                    onError(errorify(result.error));
-                } else {
-                    onResult(result.result);
-                }
-                if (writes && config?.onWritesCommitted) {
-                    config.onWritesCommitted(writes);
-                }
-            }
-        });
-        let result = await resultPromise;
-        // NOTE: Now we ALWAYS wait, to prevent services from terminating their process before their writes finish.
-        //  It is just too hard to remember to call pathValueCommitter.waitForValuesToCommit in every service.
-        if (options.canWrite && anyWrites && !options.dryRun && !options.noWaitForCommit) {
-            await pathValueCommitter.waitForValuesToCommit();
-        }
-        return result;
-    }
-    /** Run the same as usual, but instead of committing writes, returns them. */
-    public async dryRun(
-        options: Omit<WatcherOptions<any>, "onResultUpdated" | "onWriteCommitted">
-    ): Promise<PathValue[] | undefined> {
-        let result = await this.dryRunFull(options);
-        return result.writes;
-    }
-    /** Run the same as usual, but instead of committing writes, returns them. */
-    public async dryRunFull(
-        options: Omit<WatcherOptions<any>, "onResultUpdated" | "onWriteCommitted">
-    ): Promise<DryRunResult> {
-        type Result = {
-            writes: PathValue[];
-            readPaths: Set<string>
-            readParentPaths: Set<string>;
-            result: unknown;
-        };
-        let onResult!: (result: Result) => void;
-        let onError!: (error: Error) => void;
-        let resultPromise = new Promise<Result>((resolve, reject) => { onResult = resolve; onError = reject; });
-        let watcher = this.createWatcher({
-            ...options,
-            canWrite: true,
-            dryRun: true,
-            temporary: true,
-            onResultUpdated: (result, values, watcher) => {
-                watcher.dispose();
-                if ("error" in result) {
-                    onError(errorify(result.error));
-                } else {
-                    onResult({
-                        writes: values ?? [],
-                        readPaths: new Set(watcher.pendingWatches.paths),
-                        readParentPaths: new Set(watcher.pendingWatches.parentPaths),
-                        result: result.result
-                    });
-                }
-            }
-        });
-        let result = await resultPromise;
-        return result;
-    }
-
-
-    private allWatchers = registerResource("paths|proxyWatcher.allWatchers", new Set<SyncWatcher>());
-    private allWatchersLookup = registerResource("paths|proxyWatcher.allWatchersLookup", new Map<Function, SyncWatcher>());
-    public getWatcherForTrigger(trigger: Function): SyncWatcher | undefined {
-        return this.allWatchersLookup.get(trigger);
-    }
-    public getAllWatchers(): Set<SyncWatcher> {
-        return this.allWatchers;
-    }
-    public inWatcher(): boolean {
-        return !!this.runningWatcher;
-    }
-    /** @deprecated try not to call getTriggeredWatcher, and instead try to call Querysub helper
-     *      functions. getTriggeredWatcher exposes too much of our interface, which we need
-     *      to abstact out when we rewrite proxyWatcher.
-      */
-    public getTriggeredWatcher(): SyncWatcher {
-        let watcher = this.runningWatcher;
-        if (!watcher) {
-            throw new Error("Not in a watcher");
-        }
-        return watcher;
-    }
-
-    public isAllSynced(config?: {
-        ignoreAlwaysCommitAllRunsFlag?: boolean;
-    }) {
-        if (!config?.ignoreAlwaysCommitAllRunsFlag && this.runningWatcher?.options.commitAllRuns) {
-            return true;
-        }
-        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
-     *      to abstact out when we rewrite proxyWatcher.
-      */
-    public getTriggeredWatcherMaybeUndefined(): SyncWatcher | undefined {
-        return this.runningWatcher;
-    }
-
-    /** Watches everything we were watching last watch. Is essential for efficient watching code,
-     *      which needs access to a lot of state, but doesn't want to process the entire state
-     *      every time any value changes.
-     */
-    public reuseLastWatches() {
-        let watcher = this.getTriggeredWatcher();
-        for (let path of watcher.lastUnsyncedAccesses) {
-            if (!authorityStorage.isSynced(path)) {
-                watcher.pendingUnsyncedAccesses.add(path);
-            }
-        }
-        for (let path of watcher.lastUnsyncedParentAccesses) {
-            if (!authorityStorage.isParentSynced(path)) {
-                watcher.pendingUnsyncedParentAccesses.add(path);
-            }
-        }
-
-
-        function addToSet(set1: Set<string>, set2: Set<string>) {
-            let base = set2;
-            for (let path of set1) {
-                base.add(path);
-            }
-            return base;
-        }
-
-        // NOTE: If we don't clone, then pathValueClientWatcher cannot detect changes, and we
-        //  end up staying watched on everything!
-        //  - We should really fix this though, as if we can avoid this clone, we can have really efficient
-        //      incremental watches.
-        watcher.pendingWatches.paths = addToSet(new Set(watcher.lastWatches.paths), watcher.pendingWatches.paths);
-        watcher.pendingWatches.parentPaths = addToSet(new Set(watcher.lastWatches.parentPaths), watcher.pendingWatches.parentPaths);
-    }
-
-    /** NOTE: This explicitly causes the watcher to be unsynced until function
-     *      can be evaluated without any pending promises. This makes this significantly
-     *      more powerful than waiting on localState.
-     *  NOTE: IF you don't want to cause the caller to be unsynced, use a local schema instead.
-     *      This allows callers to see what path triggered them, which is often more informative
-     *      than waitReason. It also exposes the state to any synced diagnostics tools.
-     */
-    public triggerOnPromiseFinish(
-        promise: MaybePromise<unknown>,
-        config: {
-            // For example, "waitForModuleToLoad"
-            waitReason: string;
-            // Doesn't cause us to be unsynced, instead just triggering the watcher
-            //      when the promise resolves (or rejects).
-            noWait?: boolean;
-        }
-    ) {
-        // This needs to mark the watcher as unsynced
-        if (typeof promise === "object" && promise && promise instanceof Promise) {
-            let watcher = this.getTriggeredWatcher();
-            if (!config.noWait) {
-                watcher.specialPromiseUnsynced = true;
-            }
-            watcher.lastSpecialPromiseUnsyncedReason = config.waitReason;
-            void promise.finally(() => {
-                watcher.explicitlyTrigger({
-                    paths: new Set(),
-                    newParentsSynced: new Set(),
-                    pathSources: new Set(),
-                    extraReasons: [getPathStr2(`Promise`, config.waitReason || "")]
-                });
-            });
-        }
-    }
-
-    public setEventPath(getValue: () => unknown) {
-        let path = getProxyPath(getValue);
-        let watcher = this.getTriggeredWatcher();
-        watcher.pendingEventWrites.add(path);
-    }
-    public unwatchEventPaths(watcher: SyncWatcher, paths: Set<string>) {
-        for (let path of paths) {
-            watcher.lastWatches.paths.delete(path);
-            watcher.lastWatches.parentPaths.delete(path);
-            watcher.pendingWatches.paths.delete(path);
-            watcher.pendingWatches.parentPaths.delete(path);
-            watcher.pendingUnsyncedAccesses.delete(path);
-            watcher.pendingUnsyncedParentAccesses.delete(path);
-        }
-    }
-
-    public debug_breakOnWrite(proxy: string | unknown | (() => unknown)) {
-        let path = this.getPathAndWatch(proxy);
-        if (!path) {
-            console.error(`Value is not a proxy, and so cannot get path. Either pass a proxy, or a getter for a value.`);
-            return;
-        }
-        PathValueProxyWatcher.BREAK_ON_WRITES.add(path);
-    }
-    public debug_logOnWrite(proxy: unknown | (() => unknown)) {
-        let path = this.getPathAndWatch(proxy);
-        if (!path) {
-            console.error(`Value is not a proxy, and so cannot get path. Either pass a proxy, or a getter for a value.`);
-            return;
-        }
-        PathValueProxyWatcher.LOG_WRITES_INCLUDES.add(path);
-    }
-    public getPathNoWatch(proxy: string | unknown | (() => unknown)) {
-        return typeof proxy === "function" ? getProxyPath(proxy as any) : getPathFromProxy(proxy);
-    }
-    public getPathAndWatch(proxy: string | unknown | (() => unknown)) {
-        if (typeof proxy === "string") {
-            return proxy;
-        }
-
-        // Prefer to call the function, as if the result is a proxy we want the path of that,
-        //  instead of the path the proxy is inside of!
-        if (typeof proxy === "function") {
-            return getPathFromProxy(proxy()) || getProxyPathAndWatch(proxy as any);
-        }
-        return getPathFromProxy(proxy);
-    }
-
-    public ignoreWatches<T>(code: () => T) {
-        return doProxyOptions({ noSyncing: true }, code);
-    }
-}
-
-const PAINT_NOOP_FUNCTION = () => { };
-let pausedUntilNextPaint = new Map<string, () => void>();
-
-// gitHash => domainName => moduleId => schema
-let schemas = new Map<string, Map<string, Map<string, Schema2>>>();
-
-
-// NOTE: We hardcode knowledge of how module data is nested to handle schemas. This... isn't great,
-//  but it makes the code faster, and if we change how module data is nested it will break
-//  all existing data anyways, so... I don't think we ever will.
-// Path pattern is: [domain, "PathFunctionRunner", moduleId, "Data"]
-export const getMatchingSchema = cacheLimited(1000, function getMatchingSchema(pathStr: string): {
-    schema: Schema2;
-    nestedPath: string[];
-} | undefined {
-    if (_noAtomicSchema) return undefined;
-    let base = getBaseMatchingSchema(pathStr);
-    if (base) return base;
-    let prefix = getPrefixMatchingSchema(pathStr);
-    if (prefix) return prefix;
-    return undefined;
-});
-function getBaseMatchingSchema(pathStr: string): {
-    schema: Schema2;
-    nestedPath: string[];
-} | undefined {
-    let schemaForHash = (
-        schemas.get(getCurrentCallObj()?.fnc.gitRef || "ambient")
-        // Default to the ambient schema for clientside calls.
-        || schemas.get("ambient")
-    );
-
-    if (_noAtomicSchema) return undefined;
-    if (getPathIndex(pathStr, 3) !== "Data") return undefined;
-    let domain = getPathIndex(pathStr, 0)!;
-    let moduleId = getPathIndex(pathStr, 2)!;
-    let schema = schemaForHash?.get(domain)?.get(moduleId);
-    if (!schema) return undefined;
-    let nestedPathStr = getPathSuffix(pathStr, 4);
-    let nestedPath = getPathFromStr(nestedPathStr);
-    return { schema, nestedPath };
-}
-
-export function registerSchema(config: {
-    schema: Schema2;
-    domainName: string;
-    moduleId: string;
-    gitHash: string;
-}) {
-    getMatchingSchema.clear();
-
-    const { schema, domainName, moduleId, gitHash } = config;
-    let gitSchemas = schemas.get(gitHash);
-    if (!gitSchemas) {
-        schemas.set(gitHash, gitSchemas = new Map());
-    }
-
-    let domainSchemas = gitSchemas.get(domainName);
-    if (!domainSchemas) {
-        gitSchemas.set(domainName, domainSchemas = new Map());
-    }
-    domainSchemas.set(moduleId, schema);
-}
-
-export let schemaPrefixes: { len: number; prefixes: Map<string, Schema2> }[] = [];
-export function registerSchemaPrefix(config: {
-    schema: Schema2;
-    prefixPathStr: string;
-}) {
-    let len = getPathDepth(config.prefixPathStr);
-    let list = schemaPrefixes.find(x => x.len === len);
-    if (!list) {
-        schemaPrefixes.push(list = { len, prefixes: new Map() });
-    }
-    if (isNode() && !globalThis.isHotReloading?.() && !isDynamicallyLoading()) {
-        if (list.prefixes.has(config.prefixPathStr)) {
-            throw new Error(`Prefix matches only work due to only having one version of the code ever load (except for during hot reloading development clientside). If we try to render multiple versions of the same code serverside (ex, because we pre-loaded new code during a deploy), it will break, as we can't distinguish them. ADD GIT HASH TO PREFIX SCHEMAS TO FIX THIS! Tried to double load ${config.prefixPathStr}`);
-        }
-    }
-    list.prefixes.set(config.prefixPathStr, config.schema);
-}
-export function unregisterSchemaPrefix(config: {
-    schema: Schema2;
-    prefixPathStr: string;
-}) {
-    let len = getPathDepth(config.prefixPathStr);
-    let list = schemaPrefixes.find(x => x.len === len);
-    if (!list) return;
-    list.prefixes.delete(config.prefixPathStr);
-}
-function getPrefixMatchingSchema(pathStr: string): {
-    schema: Schema2;
-    nestedPath: string[];
-} | undefined {
-    let len = getPathDepth(pathStr);
-    for (let list of schemaPrefixes) {
-        if (len < list.len) continue;
-        let prefix = getPathPrefix(pathStr, list.len);
-        let schema = list.prefixes.get(prefix);
-        if (schema) {
-            let nestedPath = getPathFromStr(getPathSuffix(pathStr, list.len));
-            return { schema, nestedPath };
-        }
-    }
-    return undefined;
-}
-
-
-let _noAtomicSchema = false;
-export function noAtomicSchema<T>(code: () => T) {
-    let prev = _noAtomicSchema;
-    _noAtomicSchema = true;
-    try {
-        return code();
-    } finally {
-        _noAtomicSchema = prev;
-    }
-}
-
-
-export const proxyWatcher = new PathValueProxyWatcher();
-if ((globalThis as any).proxyWatcher) {
-    debugger;
-    console.error(`Loaded PathValueProxyWatcher twice. This will break this. In ${module.filename}`);
-}
-(globalThis as any).proxyWatcher = proxyWatcher;
-(globalThis as any).ProxyWatcher = PathValueProxyWatcher;
-// Probably the most useful debug function for debugging watch based functions.
-(globalThis as any).getCurrentTriggers = function () {
-    return proxyWatcher.getTriggeredWatcher().triggeredByChanges;
-};
-(globalThis as any).getAllWatchers = function () {
-    return proxyWatcher.getAllWatchers();
-};
-
-registerPeriodic(function checkForZombieWatches() {
-    let now = Date.now();
-    const threshold = 30 * 1000;
-    function isZombieWatch(watcher: SyncWatcher) {
-        if (watcher.options.static) return false;
-        if (!watcher.hasAnyUnsyncedAccesses()) return false;
-        let timeSinceLastSync = now - watcher.lastSyncTime;
-        if (timeSinceLastSync < threshold) return false;
-        return true;
-    }
-
-    let zombies = Array.from(proxyWatcher.getAllWatchers()).filter(isZombieWatch);
-    lastZombieCount = zombies.length;
-    if (zombies.length > 0) {
-        let namesSet = new Set(zombies.map(x => x.debugName));
-        console.warn(`Found ${zombies.length} zombie watchers`, { names: Array.from(namesSet) });
-    }
-});
-
-
-let evaluations = 0;
-let wastedEvaluations = 0;
-
-registerMeasureInfo(() => {
-    if (evaluations === 0) return undefined;
-    let current = wastedEvaluations / evaluations;
-    wastedEvaluations = 0;
-    evaluations = 0;
-    return `${formatPercent(current)} NOOP triggers`;
-});
-
-
-let triggerCount = 0;
-let triggersDropped = 0;
-registerMeasureInfo(() => {
-    if (triggerCount === 0) return undefined;
-    let current = triggersDropped / triggerCount;
-    triggersDropped = 0;
-    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'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}`],
-            });
-        }
-    }
-);
-export 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;
-}
-
-
-registerPeriodic(function logWatcherTypes() {
-    let allWatchers = proxyWatcher.getAllWatchers();
-    let counts = new Map<string, { count: number; }>();
-    for (let watcher of allWatchers) {
-        let type = watcher.debugName.split("|")[0] || "no debug name";
-        let countObj = counts.get(type);
-        if (!countObj) {
-            countObj = { count: 0 };
-            counts.set(type, countObj);
-        }
-        countObj.count++;
-    }
-    let sorted = sort(Array.from(counts.entries()), x => -x[1].count);
-
-    console.log(`${formatNumber(allWatchers.size)} watchers | ${formatNumber(sorted.length)} types | remember, components have 3 watchers`);
-    // Log the top 5
-    for (let [type, countObj] of sorted.slice(0, 5)) {
-        let countText = `${formatPercent(countObj.count / allWatchers.size)} (${formatNumber(countObj.count)})`;
-        console.log(`    ${countText.padEnd(15, " ")}    ${type}`);
-    }
-});
-
-// #endregion Proxy Ordering
-
-import { inlineNestedCalls } from "../3-path-functions/syncSchema"; import { LOCAL_DOMAIN_PATH } from "../0-path-value-core/PathRouter";
-import { waitIfReceivedIncompleteTransaction } from "./TransactionDelayer";
-
+import { measureCode, measureWrap, registerMeasureInfo } from "socket-function/src/profiling/measure";
+import { SocketFunction } from "socket-function/SocketFunction";
+import { binarySearchBasic, binarySearchBasic2, binarySearchIndex, deepCloneJSON, getKeys, insertIntoSortedList, isNode, recursiveFreeze, sort, 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, 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";
+import { getThreadKeyCert } from "../-a-auth/certs";
+import { ActionsHistory } from "../diagnostics/ActionsHistory";
+import { registerResource } from "../diagnostics/trackResources";
+import { ClientWatcher, WatchSpecData, clientWatcher } from "../1-path-client/pathValueClientWatcher";
+import { createPathValueProxy, getPathFromProxy, getProxyPath, getProxyPathAndWatch, isValueProxy, isValueProxy2 } from "./pathValueProxy";
+import { authorityStorage, compareTime, ReadLock, epochTime, getNextTime, MAX_ACCEPTED_CHANGE_AGE, PathValue, Time, getCreatorId, getTimeUnique } from "../0-path-value-core/pathValueCore";
+import { runCodeWithDatabase, rawSchema } from "./pathDatabaseProxyBase";
+import debugbreak from "debugbreak";
+import { pathValueCommitter } from "../0-path-value-core/PathValueController";
+import { pathValueSerializer } from "../-h-path-value-serialize/PathValueSerializer";
+import { registerPeriodic } from "../diagnostics/periodic";
+import { remoteWatcher } from "../1-path-client/RemoteWatcher";
+import { Schema2, Schema2Fncs } from "./schema2";
+import { devDebugbreak, getDomain, isDynamicallyLoading, isPublic } from "../config";
+
+import type { CallSpec } from "../3-path-functions/PathFunctionRunner";
+import type { FunctionMetadata } from "../3-path-functions/syncSchema";
+
+import { DEPTH_TO_DATA, MODULE_INDEX, getCurrentCall, getCurrentCallObj } from "../3-path-functions/PathFunctionRunner";
+import { interceptCallsBase, runCall } from "../3-path-functions/PathFunctionHelpers";
+import { deepCloneCborx } from "../misc/cloneHelpers";
+import { formatNumber, 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
+//  2) Commit/watch/unwatch
+// With a harness that joins the two parts in a loop (mostly powered by clientWatcher,
+//      which can run the trigger loop).
+
+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> {
+    /** NOTE: If you try to run too far in the past, an error will occur.
+     *  - This both sets the read time, and write time.
+     *  - setCurrentReadTime can also set the read time (but runAtTime is the only
+     *      way to set the write time).
+     */
+    runAtTime?: Time;
+
+    /** NOTE: Write values are only committed after we have all reads synced. */
+    canWrite?: boolean;
+
+    /** ONLY allowed if the writes and reads are all local (throws if any non-local accesses are attempted).
+     *  - Stops lock creation. This might increase speed?
+     */
+    noLocks?: boolean;
+    /** No locks, without the local-only restriction. A lot more unsafe. Don't use for any writes
+     *      that will eventually be committed (we only use it in prediction code, and GC). */
+    unsafeNoLocks?: boolean;
+
+    /** Causes us to read without counting as reading, so we don't sync any values, or
+     *      add them to our locks. Usually only set temporarily inside of a watcher,
+     *      so it can read sync values in order to write non-synced side-effects, without
+     *      having to rerun if those synced values change (as the non-synced side-effects won't
+     *      be undone, so rerunning wouldn't matter).
+     *      - qreact uses this for component traversal to set disposing flags, as disposing flags
+     *          are non-synced, and just for optimization, so there's no reason to watch the component
+     *          hierarchy when changing them.
+     */
+    noSyncing?: boolean;
+
+
+    /** Doesn't allow reading any values, but... also causes allows the function to have
+     *      no readLocks! (so it can't be rejected)
+     *  - Still allows reading back your own writes though...
+     *  - Doesn't write object parents, which breaks Object.getKeys(), unless you use
+     *      atomicObjectWrite.
+     *  - Usually set with runImmediately
+     */
+    writeOnly?: boolean;
+
+    /** Ignore currentReadTime, and just read the latest. For use with doProxyOptions. */
+    forceReadLatest?: boolean;
+
+    /** If you are writing values you KNOW you won't reading back, set this flag to
+     *      prevent caching of the writes clientside (which is a lot more efficient).
+     *      - More for testing purposes, as the performance benefit is basically negligible,
+     *          and the memory impact is unlikely to be an issue unless you are writing huge values.
+     */
+    doNotStoreWritesAsPredictions?: boolean;
+
+    /** See PathValue.event */
+    eventWrite?: boolean;
+
+    /** By default we read values before we write to them, and don't write if the value
+     *      would be `===`. This is usually preferred, because unneeded writes are a lot
+     *      more expensive than unneeded reads. However, if you are writing a lot, and you
+     *      know the values will be different, you can set this to reduce the amount of reads.
+     *  This is implicitly used for atomic writes (both due to atomicObjectWrite, or atomicWrites: true),
+     *      otherwise almost all atomic writes would result in an infinite loop, as usually
+     *      objects aren't === (and we don't deep compare objects on writes).
+     */
+    forceEqualWrites?: boolean;
+
+    atomicWrites?: boolean;
+
+    debugName?: string;
+    source?: string;
+
+    watchFunction: () => Result;
+    baseFunction?: Function;
+
+    // Only called after all the reads are synced
+    //  - getTriggeredWatcher will function correctly in this callback
+    onResultUpdated?: (
+        result: { result: Result } | { error: string },
+        writes: PathValue[] | undefined,
+        watcher: SyncWatcher
+    ) => void;
+
+    onCallCommit?: (call: CallSpec, metadata: FunctionMetadata) => void;
+
+    /** Causes us to not actually write values (we still sync new values, etc),
+     *      we just don't actually commit any writes. */
+    dryRun?: boolean;
+
+    /** Runs immediately, returning immediately, not waiting for any values to synchronize.
+     *      - Also disposes it immediately, as it isn't watching any values
+     *      - Does not even START to synchronize any values
+    */
+    runImmediately?: boolean;
+
+    /** By default we call pathValueCommitter.waitForValuesToCommit. This skips that check. */
+    noWaitForCommit?: boolean;
+
+    /** HACK: Used in conjuction with specific callers to prevent disposing, so the watcher
+     *      can be reused for specific cases.
+     */
+    static?: boolean;
+
+    /** Runs the inner function and calls the callback, even if there are unsynced values. */
+    allowUnsyncedReads?: boolean;
+
+    // NOTE: We create a new checker every single run
+    getPermissionsCheck?: () => PermissionsChecker;
+
+    skipPermissionsCheck?: boolean;
+
+    /** Default is after, which runs nested calls after the function runs (and only if all the
+     *      data is synchronized)
+     *      "inline" results in calls being run immediately, instead of queued.
+     *          TODO: We can only inline calls on the same domain, as we don't have
+     *              permissions for calls on other domains. In this case we might want to throw
+     *              ("after" is complicated due to FunctionRunner).
+     * */
+    nestedCalls?: "throw" | "after" | "ignore" | "inline";
+
+    /** These domains are allowed to be referenced by locks. Can be overriden, so you can invalidate based on on other domains
+     *      (ex, predict the server from the client).
+     *      - Defaults to the current domain, which is the safest option (as invalidating based on other domains can cause
+     *          security issues, reliability issues, etc).
+     */
+    overrideAllowLockDomainsPrefixes?: string[];
+
+    /** See WatchSpec.orderGroup */
+    order?: number;
+    orderGroup?: number;
+
+    synchronousInit?: boolean;
+
+    overrides?: PathValue[];
+
+    // Triggers are also tracked if ProxyWatcher.TRACK_TRIGGERS (or ClientWatcher.DEBUG_TRIGGERS)
+    // Sometimes we need trigger tracking for delta watchers, so this isn't just for debugging
+    trackTriggers?: boolean;
+
+    // Fairly self explanatory. If there are nested createWatchers, instead of forking, we just
+    //  run them immediately.
+    inlineNestedWatchers?: boolean;
+
+    // Temporary indicates after becoming synchronizes it will immediately dispose itself
+    temporary?: boolean;
+
+    // MUCH faster for large data (which otherwise requires a deep clone), but if it does return a proxy, and you access it in non-commit, it will throw.
+    allowProxyResults?: boolean;
+
+    /** Prevents us from (ever) tracking this as a wasted evaluation.
+     *      (indicates that this function changes non-synced states)
+     *  - Ex, qreact's mounter sets this, as it changes the DOM.
+     *  - If you are watching for the purpose of logging, or writing to files, you would set this.
+     *  - A lot of serverside watchers will set this (such as PathFunctionRunner)
+     */
+    hasSideEffects?: boolean;
+
+    /** Takes any runs with the same runOncePerPaint (globally, across all watchers),
+     *      and only runs them once per paint per group. Any excessive runs will be culled,
+     *      with the latest call being rerun after the next paint.
+     *      - If "runImmediately" or "temporary" is set, the latest call won't be rerun after the
+     *          next paint (it will be dropped).
+     *      - This should often be an id unique to the specific watcher. Otherwise
+     *          you may have watchers left in a outdated state. However, this might be
+     *          what you want, it depends on the usecase.
+     */
+    runOncePerPaint?: string;
+
+    /** Logs time to go from unsynced to synced, and the paths that were unloaded.
+     *      - In order to tell what paths to pre-load, and how much time we are waiting to load data.
+     *      - Also to tell us how long and how many paths are loading on startup.
+    */
+    logSyncTimings?: boolean;
+
+    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;
+
+    /** AKA, isAllSynced is always true. Useful for cases when we want to show partially loaded values. */
+    commitAllRuns?: boolean;
+
+
+    /** Path values contain some information about all the paths that were written at once, which we call a transaction. We can use this to detect when we are missing part of a transaction and wait until we receive that part of the transaction. 
+        - If we don't wait, our writes will get rejected, and so the system will still be valid, however, there are a few reasons we want to avoid this:
+            - If we are trying to trigger external data, such as API calls, we want to reduce raise conditions. The values still might be rejected entirely, however, at least there won't be a partial read, whereas partial reads are significantly more common than rejections. 
+            - Rejections can cause view stuttering, where the view goes to a bad state before it goes to a good state. If we just wait for the transaction to complete before trying to commit a value, such as in function runner, we can remove this stutter.
+            - Waiting can be more efficient than committing it and having to reject it, especially if something else depends on our value and then it has to be rejected and rerun. 
+            - Not all writers will automatically rerun on rejections. They should be able to handle rejections. However, it might cause downtime and it might have to put the system into a partial recovery state. It's better to avoid this and just wait for the full transaction. 
+        - Because this is so useful and so cheap to calculate, this flag will be set by default by most commit-style templates. It should be safe to set in watch style templates, However, it's not on by default there as, technically speaking, waiting for incomplete transactions will cause higher latency to render, And by default we prefer to render fast and usually get it right rather than render slow and always render the right thing. 
+     */
+    waitForIncompleteTransactions?: boolean;
+
+    // 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;
+// NOTE: Only the % waiting for active watchers. Which... is fine
+addStatPeriodic({
+    title: "Performance|Watcher % Waiting",
+    getValue: () => {
+        let totalLoop = harvestableReadyLoopCount + harvestableWaitingLoopCount;
+        if (totalLoop === 0) return 0;
+        let frac = harvestableWaitingLoopCount / totalLoop;
+        harvestableWaitingLoopCount = 0;
+        harvestableReadyLoopCount = 0;
+        return frac;
+    },
+    format: formatPercent,
+});
+addStatPeriodic({
+    title: "Performance|Stalled Watchers",
+    getValue: () => lastZombieCount,
+});
+
+
+//  Used to prevent local rejections on remote values (as local functions aren't rerun)
+//  Also used for security on servers, so they can read from untrusted domains, but can't have values
+//      rejected by untrusted domains.
+const getAllowedLockDomainsPrefixes = function getTrustedDomains(): string[] {
+    if (isNode()) {
+        return [getPathStr1(getDomain())];
+    } else {
+        // TODO: We COULD allow non-local watches on clients? This would allow something such as...
+        //  clicking on a button to go the first page that no other user is on... to revert if
+        //  another user clicks at the same time and we race. Or... something? Maybe there
+        //  are no cases when we need it... and it would definitely slow things down, so...
+        //  maybe we just don't?
+        return [LOCAL_DOMAIN_PATH];
+    }
+};
+
+export type SyncWatcher = {
+    seqNum: number;
+    options: WatcherOptions<any>;
+
+    dispose: () => void;
+    disposed?: boolean;
+    // Reset every time the function is run, so this can be subscribed to every run, but will
+    //  only be called once the final commit.
+    onInnerDisposed: (() => void)[];
+    // Runs after any trigger happens (usually multiple triggers are required for a commit)
+    onAfterTriggered: (() => void)[];
+
+    // Not great, but... sometimes we just want to trigger the function
+    explicitlyTrigger: (changes?: WatchSpecData) => void;
+
+    hasAnyUnsyncedAccesses: () => boolean;
+
+    //  - epochTime results in reading the latest time
+    //  - time is exclusive, so if you set the time of an existing write, you won't
+    //      read back it's writes.
+    setCurrentReadTime: <T>(time: Time, code: () => T) => T;
+    //  NOTE: Use the setCurrentReadTime helper, to prevent accidentally
+    //      leaving the read time set (or use runAtTime in the options,
+    //      to set it forever).
+    currentReadTime: Time | undefined;
+    nextWriteTime: Time | undefined;
+
+    debugName: string;
+
+    // The changes which triggered the current run (or last run if we are not currently running).
+    triggeredByChanges: undefined | WatchSpecData;
+
+    pendingWrites: Map<string, unknown>;
+    pendingEventWrites: Set<string>;
+    pendingCalls: { call: CallSpec; metadata: FunctionMetadata }[];
+
+    pendingWatches: {
+        paths: Set<string>;
+        parentPaths: Set<string>;
+    };
+
+    // These aren't set until after a run finishes
+    lastWatches: {
+        paths: Set<string>;
+        parentPaths: Set<string>;
+    };
+
+
+    /** 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: PathValue;
+        noLocks: boolean;
+    }>>;
+    pendingEpochAccesses: Map<Time | undefined, Set<string>>;
+
+    // A necessity for react rendering, as rendering unsynced data almost always looks bad,
+    //  so we need to show the previously rendered data when we have unsynced data.
+    //  (Although, there is a certain pleasantness to showing SOME change extremely fast,
+    //  even if it's a somewhat broken state, so... we might at a mode to allow rendering
+    //  with unsynced data).
+    //  TODO: We might make this a function, and lazily calculate it. That way we can batch reads
+    //      without having to check isSynced?
+    // NOTE: The "pendingUnsynced" must ALWAYS also set pendingWatches
+    pendingUnsyncedAccesses: Set<string>;
+    lastUnsyncedAccesses: Set<string>;
+
+    pendingUnsyncedParentAccesses: Set<string>;
+    lastUnsyncedParentAccesses: Set<string>;
+
+    specialPromiseUnsynced: boolean;
+    lastSpecialPromiseUnsynced: boolean;
+    lastSpecialPromiseUnsyncedReason?: string;
+
+    consecutiveErrors: number;
+    countSinceLastFullSync: number;
+    lastSyncTime: number;
+    syncRunCount: number;
+    startTime: number;
+
+    lastEvalTime: number;
+    inThrottle?: boolean;
+
+    permissionsChecker?: PermissionsChecker;
+
+    /** Allows us to tag the object for heap analysis */
+    tag: SyncWatcherTag;
+
+    hackHistory: { message: string; time: number }[];
+
+    createTime: number;
+
+    logSyncTimings?: {
+        startTime: number;
+        unsyncedPaths: Set<string>;
+        unsyncedStages: {
+            paths: string[];
+            time: number;
+        }[];
+    };
+}
+function addToHistory(watcher: SyncWatcher, message: string) {
+    watcher.hackHistory.push({ message, time: Date.now() });
+}
+
+
+// NOTE: A lot of our proxy callback functionality is partially duplicated in PathTimeRunner
+export let atomicObjectSymbol = Symbol.for("atomicObject");
+export function atomicObjectWrite<T>(obj: T): T {
+    if (canHaveChildren(obj) && Object.isExtensible(obj)) {
+        (obj as any)[atomicObjectSymbol] = true;
+    }
+    return recursiveFreeze(obj);
+}
+export function atomicCloneWrite<T>(obj: T): T {
+    return atomicObjectWrite(deepCloneJSON(obj));
+}
+export function atomicObjectWriteNoFreeze<T>(obj: T): T {
+    if (canHaveChildren(obj) && Object.isExtensible(obj)) {
+        (obj as any)[atomicObjectSymbol] = true;
+    }
+    return obj;
+}
+const readNoProxy = Symbol.for("readNoProxy");
+// Specifies we are reading this object, and not any children of it
+export function atomicObjectRead<T>(obj: T): T {
+    if (!isValueProxy(obj)) return obj;
+    return (obj as any)[readNoProxy];
+}
+export const atomic = atomicObjectRead;
+(globalThis as any).atomic = atomic;
+
+export function doUnatomicWrites<T>(callback: () => T): T {
+    return doProxyOptions({ atomicWrites: false }, callback);
+}
+export function doAtomicWrites<T>(callback: () => T): T {
+    return doProxyOptions({ atomicWrites: true }, callback);
+}
+
+const rawRead = Symbol.for("rawRead");
+/** Reads the raw value, which includes transparent values.
+ *      - Basically just useful for testing if an object exists in a lookup, in which case
+ *          specialObjectWriteValue will be returned for the object.
+ *      - NEVER returns a proxy, always a real object (which might be undefined, or an object).
+ */
+export function atomicRaw<T>(obj: T): T {
+    if (!isValueProxy(obj)) return obj;
+    return (obj as any)[rawRead];
+}
+
+export function doProxyOptions<T>(options: Partial<WatcherOptions<any>>, callback: () => T): T {
+    let watcher = proxyWatcher.getTriggeredWatcher();
+    let prev = watcher.options;
+    watcher.options = { ...watcher.options, ...options };
+    try {
+        return callback();
+    } finally {
+        watcher.options = prev;
+    }
+}
+
+// HACK: A special value which acts like undefined, EXCEPT when using Object.keys(). The reason it can't
+//  be undefined, is that undefined values are removed by garbage collection, and this has to stick around!
+//  - Is automatically set in the parents paths of object writes, so Object.keys() works.
+//      (Which makes garbage collection a lot harder, but... not impossible, and Object.keys() is so important
+//          that it is okay).
+//  - Due to permissions rejecting root writes, BUT, the ease of this value getting nito relatively root paths
+//      (although hopefully not THE root), reading this counts as a "readIsUndefined"
+//      NOTE: Yes, this does technically mean you depend on the first value to write to an object.
+//          And so, if the first write is rejected, the lock becomes rejected, even though
+//          there might be other writes. This is fine, because the first value is the oldest, so
+//          the least likely to be rejected, and if it is... FunctionRunner will just rerun
+//          the dependent call, and find the key exists again, and the only difference will
+//          be a bit of lag, and value flicker.
+export const specialObjectWriteValue = "_specialObjectWriteValue_16c4c3bb43f24111976a2681c972f6f4";
+export const specialObjectWriteSymbol = Symbol("specialObjectWriteSymbol");
+// Values that don't add another proxy layer
+export function isTransparentValue(value: unknown) {
+    return (
+        value === undefined
+        || value === specialObjectWriteValue
+    );
+}
+
+export function undeleteFromLookup<T>(lookup: { [key: string]: T }, key: string): void {
+    lookup[key] = {} as any;
+}
+
+const syncedSymbol = Symbol.for("syncedSymbol");
+// HACK: This should probably be somewhere else, but... it is just so useful for PathFunctionRunner...
+/** @deprecated this is not very accurate (it breaks for schema accesses). Only use it for low level places that can't call the more accurate Querysub.isSynced) */
+export function isSynced(obj: unknown): boolean {
+    // If it is a primitive, then it must be synced!
+    if (!canHaveChildren(obj)) return true;
+    if (!isValueProxy(obj)) return true;
+    return !!(obj[syncedSymbol]);
+}
+
+export type PermissionsChecker = {
+    checkPermissions(path: string): { permissionsPath: string; allowed: boolean; };
+};
+
+
+class SyncWatcherTag { }
+
+function isRecursiveMatch(paths: Set<string>, path: string): boolean {
+    if (paths.size === 0) return false;
+    if (paths.has(path)) return true;
+    for (let otherPath of paths) {
+        if (path.includes(otherPath) || otherPath.includes(path)) {
+            return true;
+        }
+    }
+    return false;
+}
+function removeMatches(paths: Set<string>, path: string): void {
+    paths.delete(path);
+    for (let otherPath of paths) {
+        if (path.includes(otherPath) || otherPath.includes(path)) {
+            paths.delete(otherPath);
+        }
+    }
+}
+
+export class PathValueProxyWatcher {
+    public static BREAK_ON_READS = new Set<string>();
+    public static BREAK_ON_WRITES = new Set<string>();
+    public static SET_FUNCTION_WATCH_ON_WRITES = new Set<string>();
+    public static LOG_WRITES_INCLUDES = new Set<string>();
+
+    // getPathStr(ModuleId, FunctionId)
+    public static BREAK_ON_CALL = new Set<string>();
+
+    public static DEBUG = false;
+    /** NOTE: This results in VERY slow performance, and will log A LOT of information. */
+    public static TRACE = false;
+    public static TRACE_WRITES = false;
+    public static TRACE_WATCHERS = new Set<string>();
+
+    public static TRACK_TRIGGERS = false;
+
+    private SHOULD_TRACE(watcher: SyncWatcher) {
+        return PathValueProxyWatcher.DEBUG || PathValueProxyWatcher.TRACE || PathValueProxyWatcher.TRACE_WRITES && watcher.options.canWrite || ClientWatcher.DEBUG_TRIGGERS === "heavy" || PathValueProxyWatcher.TRACE_WATCHERS.size > 0 && Array.from(PathValueProxyWatcher.TRACE_WATCHERS).some(x => watcher.debugName.includes(x));
+    }
+
+    private isUnsyncCheckers = new Set<{ value: number }>();
+
+    public countUnsynced = <T>(checker: { value: number }, code: () => T): T => {
+        this.isUnsyncCheckers.add(checker);
+        try {
+            return code();
+        } finally {
+            this.isUnsyncCheckers.delete(checker);
+        }
+    };
+
+    public getCallbackPathValue = (pathStr: string, syncParentKeys?: "parentKeys"): PathValue | undefined => {
+        const watcher = this.runningWatcher;
+        if (!watcher) {
+            debugger;
+            throw new Error(`Tried to get path "${pathStr}" outside of a watcher function.`);
+        }
+
+        if (watcher.options.noLocks && !pathStr.startsWith(LOCAL_DOMAIN_PATH)) {
+            throw new Error(`Tried to read a non-local path in a "noLocks" watcher, ${watcher.debugName}, path ${pathStr}`);
+        }
+
+        if (watcher.permissionsChecker) {
+            if (!watcher.permissionsChecker.checkPermissions(pathStr).allowed) {
+                if (
+                    !watcher.hasAnyUnsyncedAccesses()
+                    && authorityStorage.DEBUG_hasAnyValues(pathStr)
+                    // HACK: Don't show warnings for some framework paths, because they are filling up the console logs
+                    //  and don't really matter. We could just not request them, but at depth 3 is valid,
+                    //  so we kind of have to request that. And at depth 2, it would require special case code,
+                    //  in a bunch of annoying places.
+                    && (getPathIndex(pathStr, 1) !== "PathFunctionRunner" || getPathDepth(pathStr) > 3)
+                ) {
+                    console.warn(`Denied read access to path "${pathStr}"`);
+                    // console.warn(`${new Date().toLocaleTimeString()} Denied read access to path "${pathStr}"`);
+                    // console.warn(new Error().stack);
+                }
+                // This undefined MIGHT cause issues, but... it also makes it easier to check if
+                //  we have permissions, and more clear if we are denied permissions.
+                return undefined;
+            }
+        }
+
+        if (watcher.options.writeOnly) {
+            return undefined;
+        }
+
+        const currentReadTime = watcher.options.forceReadLatest ? undefined : watcher.currentReadTime;
+
+        let pathValue = authorityStorage.getValueAtTime(pathStr, currentReadTime);
+        if (!watcher.options.noSyncing) {
+            // NOTE: If we have any value, we are always synced (that's what synced means, as if we aren't syncing,
+            //  we delete any values, to prevent stale values from being used).
+            if (!pathValue) {
+                // NOTE: We might not have a value simply due to reading too far back in time,
+                //  so we have to call isSynced just to be sure it is actually unsynced
+                if (!authorityStorage.isSynced(pathStr)) {
+                    for (let checker of this.isUnsyncCheckers) {
+                        checker.value++;
+                    }
+                    watcher.pendingUnsyncedAccesses.add(pathStr);
+                }
+            }
+            if (syncParentKeys) {
+                if (!authorityStorage.isParentSynced(pathStr)) {
+                    watcher.pendingUnsyncedParentAccesses.add(pathStr);
+                }
+            }
+            watcher.pendingWatches.paths.add(pathStr);
+            if (syncParentKeys) {
+                watcher.pendingWatches.parentPaths.add(pathStr);
+            }
+
+            if (!pathValue) {
+                let pendingNullAccesses = watcher.pendingEpochAccesses.get(currentReadTime);
+                if (!pendingNullAccesses) {
+                    pendingNullAccesses = new Set();
+                    watcher.pendingEpochAccesses.set(currentReadTime, pendingNullAccesses);
+                }
+                pendingNullAccesses.add(pathStr);
+                return undefined;
+            } else {
+                let readValues = watcher.pendingAccesses.get(currentReadTime);
+                if (!readValues) {
+                    readValues = new Map();
+                    watcher.pendingAccesses.set(currentReadTime, readValues);
+                }
+                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() || 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)) {
+                const unwatch = () => PathValueProxyWatcher.BREAK_ON_READS.delete(pathStr);
+                debugger;
+                unwatch;
+            }
+        }
+        const watcher = this.runningWatcher;
+        if (!watcher) {
+            debugger;
+            throw new Error(`Tried to get path "${pathStr}" outside of a watcher function.`);
+        }
+
+        // IMPORTANT! If we read a value we wrote, we don't need to incur a watch!
+        // NOTE: If we wrote undefined, then that DOESN'T clobber child values, as it actually
+        //  deletes values, so... it doesn't count as having a value.
+        //  - ALSO, writing undefined allows us to then read child values, which is odd,
+        //      but is the correct behavior.
+        if (watcher.pendingWrites.has(pathStr)) {
+            let pendingValue = watcher.pendingWrites.get(pathStr);
+            let isPendingTransparent = isTransparentValue(pendingValue);
+            if (isPendingTransparent) {
+                if (readTransparent) {
+                    return { value: pendingValue };
+                } else {
+                    return undefined;
+                }
+            } else {
+                return { value: pendingValue };
+            }
+        }
+
+        let pathValue = this.getCallbackPathValue(pathStr, syncParentKeys);
+
+        if (!pathValue || !readTransparent && isTransparentValue(pathValueSerializer.getPathValue(pathValue))) {
+            let schema2 = getMatchingSchema(pathStr);
+            if (schema2) {
+                let atomicObj = Schema2Fncs.isAtomic(schema2.schema, "read", schema2.nestedPath);
+                if (atomicObj) {
+                    return { value: atomicObj.defaultValue };
+                }
+                // Check if the object should be an object. Objects can be read though, if they've
+                //      been initialized as an object (with specialObjectWriteValue). OTHERWISE,
+                //      they require initialization (root.object = {}).
+                if (Schema2Fncs.isObject(schema2.schema, schema2.nestedPath)) {
+                    // IMPORTANT! It MAY seem, like we can just add a special "deleteObjectValue_1f548f4a01cb4c35bc7b559d8dd74c42"
+                    //      sentinel, and use that to delete something (both in proxy, and in gc, so it really recursively deletes it),
+                    //      BUT, that has one major issue. Once that sentinel is truly deleted, the value will evaluate a proxy again,
+                    //      which will cause GC to change the state, which would be a bug. Not to mention accessing not existing
+                    //      keys would return a proxy, which is annoying. So... this is the best approach.
+                    if (pathValueSerializer.getPathValue(pathValue) !== specialObjectWriteValue) {
+                        // Means the key was deleted (`delete lookup[key]`), and so the intention is for this
+                        //      to terminate in undefined.
+                        return { value: undefined };
+                    }
+                }
+            }
+            return undefined;
+        } else {
+            let readValue = pathValueSerializer.getPathValue(pathValue);
+            // Unescape specialObjectWriteValue-like strings
+            if (typeof readValue === "string" && readValue.length > specialObjectWriteValue.length && readValue.startsWith(specialObjectWriteValue)) {
+                readValue = readValue.slice(0, -1);
+            }
+            return { value: readValue };
+        }
+    };
+
+    // We exclude undefined, BUT, we include "null", etc.
+    //  - This differs from javascript, but... due to how deletions work, we can't/don't differentiate between
+    //      a deleted value and undefined, and a lot of things break if deleting a value doesn't remove it from an "in" check!
+    private hasCallback = (pathStr: string): boolean => {
+        let value = this.getCallback(pathStr, undefined, "readTransparent");
+        return value?.value !== undefined;
+    };
+
+    private setCallback = (pathStr: string, value: unknown, inRecursion = false, allowSpecial = false): void => {
+        if (PathValueProxyWatcher.BREAK_ON_WRITES.size > 0 && proxyWatcher.isAllSynced()) {
+            if (isRecursiveMatch(PathValueProxyWatcher.BREAK_ON_WRITES, pathStr)) {
+                let unwatch = () => removeMatches(PathValueProxyWatcher.BREAK_ON_WRITES, pathStr);
+                debugger;
+                unwatch;
+            }
+        }
+
+        if (PathValueProxyWatcher.SET_FUNCTION_WATCH_ON_WRITES.size > 0 && proxyWatcher.isAllSynced()) {
+            if (isRecursiveMatch(PathValueProxyWatcher.SET_FUNCTION_WATCH_ON_WRITES, pathStr)) {
+                let unwatch = () => removeMatches(PathValueProxyWatcher.SET_FUNCTION_WATCH_ON_WRITES, pathStr);
+                PathValueProxyWatcher.BREAK_ON_CALL.add(
+                    getPathStr2(getCurrentCall().ModuleId, getCurrentCall().FunctionId)
+                );
+            }
+        }
+
+        if (PathValueProxyWatcher.LOG_WRITES_INCLUDES.size > 0 && proxyWatcher.isAllSynced()) {
+            if (isRecursiveMatch(PathValueProxyWatcher.LOG_WRITES_INCLUDES, pathStr)) {
+                let unwatch = () => removeMatches(PathValueProxyWatcher.LOG_WRITES_INCLUDES, pathStr);
+                console.log(`Write path "${pathStr}" = ${value}`);
+            }
+        }
+        if (value === specialObjectWriteSymbol) {
+            value = specialObjectWriteValue;
+            allowSpecial = true;
+        }
+
+        // Escape specialObjectWriteValue-like strings
+        //  - Check for .startsWith, so we change all values. If we just added when it was ===, then
+        //      anything that === the escaped value before hand, would get unescaped, even though
+        //      it was never escaped!
+        if (!allowSpecial && typeof value === "string" && value.startsWith(specialObjectWriteValue)) {
+            value += " ";
+        }
+
+        const watcher = this.runningWatcher;
+        if (!watcher) {
+            // Ignore preact paths
+            let lastPart = getLastPathPart(pathStr);
+            if (lastPart.startsWith("__") || lastPart === "type") {
+                return;
+            }
+            debugger;
+            throw new Error(`Tried to set path "${pathStr}" outside of a watcher function.`);
+        }
+        if (!watcher.options.canWrite) {
+            throw new Error(`Tried to write to path "${pathStr}" in watcher (${watcher.debugName}) that has { canWrite: false }`);
+        }
+        if (watcher.options.noLocks && !pathStr.startsWith(LOCAL_DOMAIN_PATH)) {
+            throw new Error(`Tried to write a non-local path in a "noLocks" watcher, ${watcher.debugName}, path ${pathStr}`);
+        }
+
+        if (watcher.permissionsChecker) {
+            if (!watcher.permissionsChecker.checkPermissions(pathStr).allowed) {
+                if (value !== specialObjectWriteValue) {
+                    if (!watcher.hasAnyUnsyncedAccesses()) {
+                        // NOTE: Only throw once we sync all accesses, otherwise this could cause sync cascading, which is bad
+                        // NOTE: We COULD do the same thing for reason... but... it should be equivalent to just NOOP reads. We
+                        //      could NOOP writes as well, but throwing makes development easier (by telling you why your write
+                        //      is doing nothing more loudly than just a console warning).
+                        throw new Error(`Denied write access to path "${pathStr}"`);
+                        //console.warn(red(`Denied write access to path "${pathStr}" (ignoring write and continuing)`));
+                    }
+                }
+                return;
+            }
+        }
+
+        if (
+            !watcher.options.forceEqualWrites
+            && (
+                !canHaveChildren(value)
+                || !(atomicObjectSymbol in value || watcher.options.atomicWrites)
+            )
+        ) {
+            // NOTE: This NOOPs on predicted writes as well. BUT, we also incur a lock, so, it's fine...
+            let existingValue = this.getCallback(pathStr, undefined, "readTransparent");
+            // NOTE: We don't deep compare atomicObjectSymbol, as atomicObjectSymbol is often
+            //      used for exotic values. The user will have to deep compare themselves, if
+            //      they want to avoid the extra write.
+            if (existingValue?.value === value) {
+                return;
+            }
+        }
+
+        // Set parent specialObjectWriteValue values
+        if (
+            !watcher.options.writeOnly
+            // If we are an event write we can't set parent values, otherwise the parents will become
+            //  events, which breaks Object.keys on them (which is almost certainly not intended), because
+            //  event paths can't be watched after a certain time.
+            && !watcher.options.eventWrite
+            && !inRecursion
+            // Deletes shouldn't create parent objects!
+            && value !== undefined
+        ) {
+            if (!watcher.pendingWrites.has(pathStr)) {
+                let parentPathStr = pathStr;
+                let isLocal = pathStr.startsWith(LOCAL_DOMAIN_PATH);
+                let depthToData = isLocal ? 1 : DEPTH_TO_DATA;
+                while (true) {
+                    parentPathStr = getParentPathStr(parentPathStr);
+                    if (getPathDepth(parentPathStr) < depthToData) break;
+                    // We don't need to check all parents, as if any value is set, all parents will
+                    //  likely have their specialObjectWriteValue set, due to a previous run of this function!
+                    if (watcher.pendingWrites.has(parentPathStr)) break;
+                    let parentValue = this.getCallback(parentPathStr, undefined, "readTransparent");
+                    // If we have a value, don't set the object.
+                    //  NOTE: This means if you:
+                    //      x.y.z = 1
+                    //      delete x.y; // (OR, x.y = null)
+                    //      x.y.z = 2
+                    //      Object.keys(x.y) === ["z"]
+                    //  Which is annoying (keys show up for values you accidentally resurrected), but...
+                    //      it is somewhat required, as we don't know if you are trying to readd
+                    //      an object, or accidentally resurrected it!
+                    //      - Really you should use a flag for deletion, which will work 100% of the time,
+                    //          and make life easier for specific undoing, and also eventually... instructed garbage collection.
+                    if (parentValue?.value !== specialObjectWriteValue) {
+                        watcher.pendingWrites.set(parentPathStr, specialObjectWriteValue);
+                    }
+                }
+            }
+        }
+
+        function isAtomicSchema(pathStr: string) {
+            let schema2 = getMatchingSchema(pathStr);
+            if (schema2) {
+                let atomicObj = Schema2Fncs.isAtomic(schema2.schema, "write", schema2.nestedPath);
+                if (atomicObj) {
+                    return true;
+                    // NOTE: We can't skip if the value === default, as the previous value might not be the default,
+                    //  (so the write might change the value).
+                    //  - We could optimize the = undefined case for atomic objects, where the value is already undefined
+                    //      (but we defaulted it), but... it's probably not worth the effort.
+                }
+            }
+        }
+
+        // Destructure the value if it is an object, UNLESS, it specifies that it is atomic.
+        if (canHaveChildren(value) && !(atomicObjectSymbol in value) && !watcher.options.atomicWrites && !isAtomicSchema(pathStr)) {
+            const addWrites = (pathStr: string, value: unknown) => {
+                if (canHaveChildren(value) && !(atomicObjectSymbol in value) && !isAtomicSchema(pathStr)) {
+                    this.setCallback(pathStr, specialObjectWriteValue, true, true);
+                    const keys = getKeys(value);
+                    for (let key of keys) {
+                        if (typeof key !== "string") {
+                            throw new Error(`Cannot have non-string keys in non-atomic (atomicObjectWrite) objects. Key: "${String(key)}" at path "${pathStr}".`);
+                        }
+                        addWrites(appendToPathStr(pathStr, key), value[key]);
+                    }
+                } else {
+                    // NOTE: It is a bit inefficient in terms of computation to call setCallback, BUT, it
+                    //  allows us to automatically run our deduping checks, which saves a lot of unnecessary
+                    //  computation on other nodes (and network bandwidth, etc, etc).
+                    this.setCallback(pathStr, value, true);
+                    //watcher.pendingWrites.set(pathStr, value);
+                }
+            };
+            addWrites(pathStr, value);
+        } else {
+            if (!pathStr.startsWith(LOCAL_DOMAIN_PATH)) {
+                // Copy the value, to ensure any proxy values aren't attempted to be written
+                //      to the database. A bit slower, but... it should be fine. We COULD do this
+                //      later on, but this makes it easier to attribute lag and errors to the original source.
+                //  - If we had a proxy, we WOULD copy it eventually, but we would copy it later,
+                //      which would cause an error, because the reader wouldn't be trackable.
+                value = deepCloneCborx(value);
+            }
+            watcher.pendingWrites.set(pathStr, value);
+        }
+    };
+    /** Syncs keys AND values (as we won't return a key for a value that is undefined). */
+    public getKeys = (pathStr: string): string[] => {
+        if (getPathDepth(pathStr) < MODULE_INDEX) {
+            throw new Error(`Cannot call getKeys on path "${pathStr}" because it is too shallow. Must be at least ${MODULE_INDEX} levels deep.`);
+        }
+
+        const watcher = this.runningWatcher;
+        if (!watcher) {
+            debugger;
+            throw new Error(`Tried to getKeys on path "${pathStr}" outside of a watcher function.`);
+        }
+
+        if (watcher.permissionsChecker) {
+            if (!watcher.permissionsChecker.checkPermissions(pathStr).allowed) {
+                console.warn(`Denied read access to parentPath "${pathStr}"`);
+                return [];
+            }
+            let childPath = appendToPathStr(pathStr, Date.now() + "_" + Math.random());
+            if (!watcher.permissionsChecker.checkPermissions(childPath).allowed) {
+                console.warn(red(`Denied write access to children of parent path "${childPath}"`));
+                return [];
+            }
+        }
+
+        // Using the schema for keys is a MASSIVE optimization, despite the potential drawbacks.
+        //  - It returns all possible keys, even optional keys, which isn't the same as Object.keys()
+        //  - It ignores any keys removed from the schema, which causes JSON.stringify to behave differently
+        // HOWEVER, saving an entire serverside call, which would otherwise require a roundtrip before we could
+        //      access values inside the keys... is unbelievably useful. This reduces latency, which is the hardest
+        //      thing to remove. AND, "noAtomicSchema" can always be used to skip this optimization.
+        let schema2 = getMatchingSchema(pathStr);
+        if (schema2) {
+            let atomicKeys = Schema2Fncs.getKeys(schema2.schema, schema2.nestedPath);
+            if (atomicKeys) {
+                return atomicKeys;
+            }
+        }
+
+        // IMPORTANT: The this.getCallback is what triggers the parent watch!
+        //      We leave it up to getCallback to add the parentPaths watch, to allow Object.keys on values
+        //          that were just written with incurring a parent watch.
+        let pathValue = this.getCallback(pathStr, "parentKeys");
+        if (!isTransparentValue(pathValue?.value)) {
+            return getKeys(pathValue?.value) as string[];
+        }
+
+        let childPaths = authorityStorage.getPathsFromParent(pathStr);
+
+        // We need to also get keys from pendingWrites
+        {
+            let copiedChildPaths: Set<string> | undefined;
+            let pendingWrites = watcher.pendingWrites;
+            for (let childPath of pendingWrites.keys()) {
+                if (childPath.length > pathStr.length && childPath.startsWith(pathStr)) {
+                    if (!copiedChildPaths) {
+                        copiedChildPaths = childPaths = new Set(childPaths);
+                    }
+                    copiedChildPaths.add(childPath);
+                }
+            }
+        }
+
+        let keys = new Set<string>();
+        if (childPaths) {
+            let targetDepth = getPathDepth(pathStr);
+            for (let childPath of childPaths) {
+                let key = getPathIndexAssert(childPath, targetDepth);
+                let childValue = this.getCallback(childPath, undefined, "readTransparent");
+                if (childValue?.value !== undefined) {
+                    keys.add(key);
+                }
+            }
+        }
+
+        let keysArray = Array.from(keys);
+
+        // NOTE: Because getPathsFromParent does not preserve order, we have to sort here to ensure
+        //  we provide a consistent order (which might not be the order the user wants, but at least
+        //  it will always fail if it does fail).
+        keysArray.sort();
+
+        return keysArray;
+    };
+
+    private getSymbol = (pathStr: string, symbol: symbol): { value: unknown } | undefined => {
+        if (symbol === Symbol.toPrimitive) return {
+            value: (hint: string) => {
+                if (hint === "string") return "";
+                if (hint === "number") return 0;
+                // NOTE: Returning 0 as the default makes (x++) work nicely, defaulting values to undefined.
+                //  If they are expecting a string... maybe they should use `${x}`, or... just type check it.
+                return 0;
+            }
+        };
+        if (symbol === Symbol.toStringTag) return { value: () => `[proxy at ${pathStr}]` };
+
+        if (symbol === readNoProxy) {
+            let value = this.getCallback(pathStr)?.value;
+            return { value };
+        }
+
+        if (symbol === syncedSymbol) {
+            return { value: authorityStorage.isSynced(pathStr) };
+        }
+
+        // Proxies should be considered atomic, at least for the purpose of other proxies!
+        //  - This allows proxies to be written to synced state easily (although this will
+        //      cause issues if it isn't local synced state, but... there's not too much
+        //      we can do about that. It should just serialize it, possibly reading values
+        //      which weren't synced. Which isn't so bad, as if they start trying to create
+        //      object graphs in synced state they are going to immediately run into issues
+        //      anyways).
+        if (symbol === atomicObjectSymbol) return { value: true };
+
+        if (symbol === rawRead) {
+            return { value: this.getCallback(pathStr, undefined, "readTransparent")?.value };
+        }
+
+        return { value: undefined };
+    };
+
+    private proxy = createPathValueProxy({
+        getCallback: this.getCallback,
+        hasCallback: this.hasCallback,
+        setCallback: this.setCallback,
+        getKeys: this.getKeys,
+        getSymbol: this.getSymbol,
+    });
+
+    private runningWatcher: SyncWatcher | undefined;
+
+    // NOTE: We can't support promises until we are able to run the function on another
+    //  thread (at which point we can ensure there is no parallel function running).
+    public createWatcher<Result = void>(
+        options: WatcherOptions<Result>
+    ): SyncWatcher {
+        if (isAsyncFunction(options.watchFunction)) {
+            throw new Error(`A watcher function cannot be async, it must be synchronous. You probably did Querysub.commitAsync(async () => {}). Just remove the async, and do Querysub.commit(() => {}). The caller will be called again whenever the data you access changes, And if you are running this to return a result, it will be rerun until all the data you want is synchronized. Watch function: ${options.watchFunction.toString()}`);
+        }
+        // NOTE: Setting an order is needed for rendering, so parents render before children. I believe
+        //  it is generally what we want, so event triggering is consistent, and fits with any tree based
+        //  watching system. If this causes problems we COULD remove it from here and have just qreact.tsx set it.
+        if (options.order === undefined) {
+            options.order = nextOrderSeqNum++;
+        }
+
+        // Unwrap nested immediate calls to be as close to a naked call as possible. The watcher never becomes
+        //  the current watcher, and is immediately disposed. We only create SyncWatcher to return it, otherwise
+        //  callers would need to handle a variable return type, which is annoying.
+        //  - This means any writes are attributed to the existing call, which... is fine, if the caller wants
+        //      to disconnect the call from the existing watcher, they should use `Promise.resolve().finally(...)`.
+        // NOTE: We check for runImmediately as we still want to be able to create watchers in
+        //  reaction to trigger of other watchers.
+        if (this.runningWatcher && (options.runImmediately || this.runningWatcher.options.inlineNestedWatchers)) {
+            // TODO: We COULD change our dispose out and change it back, if we find
+            //  we often want to mutate shallow props of nested watchers.
+            const outerWatcher = {
+                ...this.runningWatcher,
+                // Let them use the watcher, EXCEPT, don't let them dispose it,
+                //  as that would dispose the outer watcher as well
+                dispose: () => { },
+            };
+            if (!this.runningWatcher.options.canWrite && options.canWrite) {
+                debugger;
+                throw new Error(`Cannot run a canWrite nested watcher inside of a watcher that can't. Either explicitly specify canWrite = true in outer watcher, canWrite = false in the inner watcher, or disconnect it with Promise.resolve().finally(...)`);
+            }
+            // NOTE: Nested watchers are fine. We need to apply the nested options
+            //  (some of which will be ignroed), but otherwise, all of the watchers
+            //  will be collapsed to a single watcher, making it fairly efficient.
+            let { watchFunction, ...mostOptions } = options;
+            doProxyOptions(mostOptions, () => {
+                try {
+                    let result = authorityStorage.temporaryOverride(options.overrides, () =>
+                        options.watchFunction()
+                    );
+                    // Clone, otherwise proxies get out of the watcher, which can result in accesses outside
+                    //  of a synced watcher.
+                    if (!options.allowProxyResults) {
+                        result = deepCloneCborx(result);
+                    } else {
+                        result = atomicObjectRead(result);
+                    }
+                    options.onResultUpdated?.({ result }, undefined, outerWatcher);
+                } catch (e: any) {
+                    options.onResultUpdated?.({ error: e.stack }, undefined, outerWatcher);
+                }
+            });
+            return outerWatcher;
+        }
+
+        const self = this;
+        if (options.runAtTime) {
+            // 80% of our real max range, so calls with a runAtTime close to our limit have a bit of breathing room to run
+            let runLeeway = MAX_ACCEPTED_CHANGE_AGE * 0.8;
+            let runCutoffTime = Date.now() - runLeeway;
+            if (options.runAtTime && options.runAtTime.time < runCutoffTime) {
+                let message = `MAX_CHANGE_AGE_EXCEEDED! Cannot run watcher ${options.debugName} at time ${options.runAtTime.time} because it is older than the cutOff time of ${runCutoffTime}. Writing this far in the past would break things, and might be rejected by other authorities due to being too old.`;
+                console.error(red(message));
+                // NOTE: We could also adjust the to be more recent, to allow it to be commited anyway,
+                //  in a slightly different state than originally expected.
+                throw new Error(message);
+            }
+        }
+
+        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 = {
+            seqNum: nextSeqNum++,
+            debugName,
+            dispose: () => { },
+            disposed: false,
+            onInnerDisposed: [],
+            onAfterTriggered: [],
+            explicitlyTrigger: () => { },
+            hasAnyUnsyncedAccesses: () => false,
+            currentReadTime: options.runAtTime,
+            nextWriteTime: undefined,
+            setCurrentReadTime: null as any,
+            pendingAccesses: new Map(),
+            pendingEpochAccesses: new Map(),
+            triggeredByChanges: undefined,
+            pendingWrites: new Map(),
+            pendingEventWrites: new Set(),
+            pendingCalls: [],
+            pendingWatches: {
+                paths: new Set(),
+                parentPaths: new Set(),
+            },
+            lastWatches: {
+                paths: new Set(),
+                parentPaths: new Set(),
+            },
+
+            pendingUnsyncedAccesses: new Set(),
+            pendingUnsyncedParentAccesses: new Set(),
+            lastUnsyncedAccesses: new Set(),
+            lastUnsyncedParentAccesses: new Set(),
+
+            specialPromiseUnsynced: false,
+            lastSpecialPromiseUnsynced: false,
+
+            options,
+            consecutiveErrors: 0,
+            countSinceLastFullSync: 0,
+            lastEvalTime: 0,
+            lastSyncTime: now,
+            startTime: now,
+            syncRunCount: 0,
+            tag: new SyncWatcherTag(),
+
+            hackHistory: [],
+            createTime: getTimeUnique(),
+        };
+        addToProxyOrder(watcher);
+        const SHOULD_TRACE = this.SHOULD_TRACE(watcher);
+        const proxy = this.proxy;
+
+        if (options.overrides && !options.dryRun) {
+            // If you override values, and want to watch values... how does that even work? And what about
+            //      writes? You can't depend on an override, so... what would we do?
+            throw new Error(`overrides without dryRun is not presently supported`);
+        }
+
+        watcher.dispose = dispose;
+        this.allWatchers.add(watcher);
+
+        let baseFunction = options.watchFunction;
+        baseFunction = measureWrap(baseFunction, watcher.debugName);
+        {
+            let base = baseFunction;
+            baseFunction = (...args: unknown[]) => {
+                let time = Date.now();
+                try {
+                    return (base as any)(...args);
+                } finally {
+                    onTimeProfile("Performance|Watcher", time);
+                }
+            };
+        }
+
+        watcher.setCurrentReadTime = (time, code) => {
+            let prev = watcher.currentReadTime;
+            watcher.currentReadTime = time;
+            try {
+                return code();
+            } finally {
+                watcher.currentReadTime = prev;
+            }
+        };
+        watcher.hasAnyUnsyncedAccesses = () => {
+            if (watcher.options.waitForIncompleteTransactions) {
+                waitIfReceivedIncompleteTransaction();
+            }
+            return (
+                watcher.pendingUnsyncedAccesses.size > 0
+                || watcher.pendingUnsyncedParentAccesses.size > 0
+                || watcher.specialPromiseUnsynced
+                || isProxyBlockedByOrder(watcher)
+            );
+        };
+        const getReadyToCommit = () => {
+            if (watcher.options.commitAllRuns) {
+                return true;
+            }
+            return (
+                watcher.lastUnsyncedAccesses.size === 0
+                && watcher.lastUnsyncedParentAccesses.size === 0
+                && !watcher.lastSpecialPromiseUnsynced
+                && !isProxyBlockedByOrder(watcher)
+            );
+        };
+        function afterTrigger() {
+            for (let i = 0; i < 10; i++) {
+                let callbacks = watcher.onAfterTriggered;
+                watcher.onAfterTriggered = [];
+                for (let callback of callbacks) {
+                    logErrors(((async () => { await callback(); }))());
+                }
+                if (watcher.onAfterTriggered.length === 0) break;
+            }
+            if (watcher.onAfterTriggered.length > 0) {
+                console.warn(`Watcher ${watcher.debugName} keeps adding after trigger callbacks during after trigger. We reached our iteration limit 
+                    and will be ignoring triggers remaining triggers.`);
+            }
+        }
+
+        function dispose() {
+            if (watcher.disposed) return;
+            watcher.disposed = true;
+            clientWatcher.unwatch(trigger);
+            self.allWatchers.delete(watcher);
+
+            // NOTE: We trigger next before onInnerDisposed, as onInnerDispose often run more commits, and if we proxy block it causes proxies to run twice.
+            // TODO: Is this guaranteed to be called all the time? What about nested proxy watchers?
+            void finishProxyAndTriggerNext(watcher);
+
+            for (let i = 0; i < 10; i++) {
+                let disposeCallbacks = watcher.onInnerDisposed;
+                watcher.onInnerDisposed = [];
+                for (let callback of disposeCallbacks) {
+                    logErrors(((async () => { await callback(); }))());
+                }
+                if (watcher.onInnerDisposed.length === 0) break;
+            }
+            if (watcher.onInnerDisposed.length > 0) {
+                console.warn(`Watcher ${watcher.debugName} keeps adding inner disposed callbacks during dispose. We reached our iteration limit 
+                    and will be ignoring dispose callbacks remaining dispose callbacks.`);
+            }
+
+            self.allWatchersLookup.delete(trigger);
+        }
+        function runWatcher() {
+            watcher.pendingWrites.clear();
+            watcher.pendingEventWrites.clear();
+            watcher.pendingCalls = [];
+            // NOTE: We have to make new sets here, because these Sets are reused for lastWatches, which makes
+            //  it's way into clientWatcher, without changing. So if we just clear it, we can break clientWatcher.
+            watcher.pendingWatches.paths = new Set();
+            watcher.pendingWatches.parentPaths = new Set();
+            watcher.pendingUnsyncedAccesses.clear();
+            watcher.pendingUnsyncedParentAccesses.clear();
+
+            watcher.pendingAccesses.clear();
+            watcher.pendingEpochAccesses.clear();
+            // 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.
+            //      - Even using Date.now() is not far enough in the future, as we might be given data a bit before Date.now() due to clock
+            //      differences. And we can't just set it arbitrarily into the future, as then we will be writing
+            //      in the future, which would cause us to become rejected on writes that happen after our real
+            //      time (but after our given time).
+            watcher.nextWriteTime = watcher.options.runAtTime;
+            // Ensure nextWriteTime is a unique time every run, in case we were rerun due to a rejection (unless it is a dryRun,
+            //  in which case the writes won't be committed, so they don't need to be unique).
+
+            // NOTE: We prefer to not set the time, as if our clock is at all in the past (or other clocks are in the future),
+            //  then when we receive a value we will ignore it.
+            if (!watcher.options.dryRun && watcher.nextWriteTime) {
+                watcher.nextWriteTime = clientWatcher.getFreeWriteTime(watcher.nextWriteTime);
+            }
+
+            // The read time equals the write time, so our locks use the same time as our write time, and
+            //  therefore lock the actual state we used.
+            watcher.currentReadTime = watcher.nextWriteTime;
+
+            watcher.permissionsChecker = options.getPermissionsCheck?.();
+
+            let result: { result: Result } | { error: string };
+            try {
+                let rawResult: Result;
+                const handling = watcher.options.nestedCalls;
+                let curFunction = baseFunction;
+                if (handling === "inline") {
+                    curFunction = () => inlineNestedCalls(baseFunction);
+                }
+                rawResult = interceptCalls({
+                    onCall(call, metadata) {
+                        if (PathValueProxyWatcher.BREAK_ON_CALL.size > 0 && !watcher.hasAnyUnsyncedAccesses()) {
+                            let hash = getPathStr2(call.ModuleId, call.FunctionId);
+                            if (PathValueProxyWatcher.BREAK_ON_CALL.has(hash)) {
+                                const unwatch = () => removeMatches(PathValueProxyWatcher.BREAK_ON_CALL, hash);
+                                debugger;
+                                unwatch;
+                            }
+                        }
+                        if (!watcher.options.canWrite) {
+                            throw new Error(`Cannot call a synced function in a watcher which does not have write permissions. If you want to call a function, you must also have write permissions.`);
+                        }
+                        if (handling === "throw") {
+                            // TODO: Support making inline calls, which is useful as it will check permissions. Although, it can
+                            //  easily be slow, and adds a lot of complexity, so... maybe not... maybe always force the app
+                            //  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) {
+                            // 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") {
+                        } else if (handling === "inline") {
+                            throw new Error(`inlineNestedCalls should have prevented this call from being passed to us`);
+                        } else {
+                            let unhandled: never = handling;
+                            throw new Error(`Invalid handling type ${handling}`);
+                        }
+                    },
+                    code() {
+                        return authorityStorage.temporaryOverride(options.overrides, () =>
+                            runCodeWithDatabase(proxy, baseFunction)
+                        );
+                    },
+                }) as Result;
+
+                // NOTE: Deep clone non-local paths. It's too confusing for a partial object to be returned. Any issues caused by
+                //  this (aka, returning the entire database), would also happen if we manually added deep clones before
+                //  we returned values (and both should be throttled at a framework level so we don't break the database).
+                //  - For local paths there is a risk that there are functions
+                if (!options.allowProxyResults) {
+                    try {
+                        rawResult = deepCloneCborx(rawResult);
+                    } catch {
+                        // Unfortunately, cborx throws on functions.
+                        // TODO: Use a recursive clone technique that doesn't throw on functions
+                        rawResult = atomicObjectRead(rawResult);
+                    }
+                } else {
+                    rawResult = atomicObjectRead(rawResult);
+                }
+
+                result = { result: rawResult };
+                watcher.consecutiveErrors = 0;
+            } catch (e: any) {
+                watcher.consecutiveErrors++;
+                if (watcher.consecutiveErrors > 10) {
+                    console.error(`Watch callback is failing a lot ${watcher.debugName} (${watcher.consecutiveErrors} times). It is possible you are throwing in a loop on unsynced values. Instead for all the values you want to check, then loop over them, otherwise syncing could take forever.`);
+                    console.error(e);
+                }
+                result = { error: e.stack };
+            } finally {
+                afterTrigger();
+                // Set the checker to undefined, so we don't accidentally use it again,
+                //  as it will throw if we try to use it after any asynchronous delay.
+                watcher.permissionsChecker = undefined;
+            }
+
+
+            let anyUnsynced = watcher.hasAnyUnsyncedAccesses();
+
+            watcher.lastUnsyncedAccesses = watcher.pendingUnsyncedAccesses;
+            watcher.lastUnsyncedParentAccesses = watcher.pendingUnsyncedParentAccesses;
+            watcher.lastSpecialPromiseUnsynced = watcher.specialPromiseUnsynced;
+
+            // 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 || {
+                        startTime: Date.now(),
+                        unsyncedPaths: new Set(),
+                        unsyncedStages: [],
+                    };
+                    let newPaths: string[] = [];
+                    let set = watcher.logSyncTimings.unsyncedPaths;
+                    function addPath(path: string) {
+                        if (set.has(path)) return;
+                        set.add(path);
+                        newPaths.push(path);
+                    }
+                    for (let path of watcher.lastUnsyncedAccesses) {
+                        addPath(path);
+                    }
+                    for (let path of watcher.lastUnsyncedParentAccesses) {
+                        addPath(path);
+                    }
+                    if (newPaths.length > 0) {
+                        watcher.logSyncTimings.unsyncedStages.push({
+                            paths: newPaths,
+                            time: Date.now(),
+                        });
+                    }
+                } else {
+                    if (watcher.logSyncTimings) {
+                        let now = Date.now();
+                        console.groupCollapsed(`${watcher.debugName} synced in ${formatTime(now - watcher.logSyncTimings.startTime)}`);
+                        // Log the stages
+                        let stages = watcher.logSyncTimings.unsyncedStages;
+                        for (let i = 0; i < stages.length; i++) {
+                            let nextTime = stages[i + 1]?.time || now;
+                            let stage = stages[i];
+                            console.groupCollapsed(`${formatTime(nextTime - stage.time)}`);
+                            for (let path of stage.paths) {
+                                console.log(path);
+                            }
+                            console.groupEnd();
+                        }
+                        console.groupEnd();
+                        watcher.logSyncTimings = undefined;
+                    }
+                }
+            }
+
+            if (!watcher.options.static) {
+                if (!anyUnsynced) {
+                    watcher.countSinceLastFullSync = 0;
+                    watcher.lastSyncTime = Date.now();
+                    watcher.syncRunCount++;
+                } else {
+                    if (watcher.countSinceLastFullSync === 0) {
+                        let syncRunCount = watcher.syncRunCount;
+                        setTimeout(() => {
+                            if (watcher.syncRunCount !== syncRunCount) return;
+                            if (watcher.disposed) return;
+                            let remainingUnsynced = Array.from(watcher.lastUnsyncedAccesses).filter(x => !authorityStorage.isSynced(x));
+                            let remainingUnsyncedParent = Array.from(watcher.lastUnsyncedParentAccesses).filter(x => !authorityStorage.isParentSynced(x));
+                            console.warn(red(`Did not sync ${watcher.debugName} after 30 seconds. Either we had a lot synchronous block, or we will never received the values we are waiting for.`), remainingUnsynced, remainingUnsyncedParent, watcher.options.watchFunction);
+                        }, 30 * 1000);
+                        setTimeout(() => {
+                            if (watcher.syncRunCount !== syncRunCount) return;
+                            if (watcher.disposed) return;
+
+                            // IMPORTANT! Any of these can be also caused by high synchronous lag!
+                            //  - If this becomes a serious concern, we could add a watch loop for this, which
+                            //      tries to run every second, recording how far it misses the target time by,
+                            //      and then uses that (plus any outstanding missed time) to determine how much lag
+                            //      we have had since this watcher last synced. If it is > 50% of the time...
+                            //      then synchronous lag is the issue.
+
+                            let reallyUnsyncedAccesses = Array.from(watcher.lastUnsyncedAccesses).filter(x => !authorityStorage.isSynced(x));
+                            let reallyUnsyncedParentAccesses = Array.from(watcher.lastUnsyncedParentAccesses).filter(x => !authorityStorage.isParentSynced(x));
+
+                            if (reallyUnsyncedAccesses.length !== 0 || reallyUnsyncedParentAccesses.length !== 0) {
+                                let notWatchingUnsynced = reallyUnsyncedAccesses.filter(x => !remoteWatcher.debugIsWatchingPath(x));
+                                let notWatchingUnsyncedParent = reallyUnsyncedParentAccesses.filter(x => !remoteWatcher.debugIsWatchingPath(x));
+                                if (notWatchingUnsynced.length !== 0 || notWatchingUnsyncedParent.length !== 0) {
+                                    console.error((`${red("WATCHER FAILED TO SYNC")} ${watcher.debugName} ${magenta("NOT REMOTE WATCHING REQUIRED PATHS")}. This means our sync or unsync (likely unsync) logic is broken, in remoteWatcher/clientWatcher. OR, there were no read nodes when we tried to sync (we don't handle missing read nodes correctly at the moment)`), notWatchingUnsynced, notWatchingUnsyncedParent, watcher.options.watchFunction);
+                                    debugbreak(2);
+                                    debugger;
+                                } else {
+                                    console.error((`${red("WATCHER FAILED TO SYNC")} ${watcher.debugName} ${magenta("DID NOT RECEIVE PATH VALUES")}. This means PathValueServer is not responding to watches, either to specific paths, or for all paths`), reallyUnsyncedAccesses, reallyUnsyncedParentAccesses, watcher.options.watchFunction);
+                                    // debugbreak(2);
+                                    // debugger;
+                                }
+                            } else if (watcher.lastSpecialPromiseUnsynced) {
+                                console.warn((`${yellow("WATCHER SLOW TO SYNC")} ${watcher.debugName} ${magenta("DEPENDENT PROMISE NEVER RESOLVED")}. This promise might resolve, but it probably won't. Slow promises should be detached from the watcher system and use multiple watchers/writes, instead of blocking on a promise.`), watcher.lastSpecialPromiseUnsyncedReason, watcher.options.watchFunction);
+                                debugbreak(2);
+                                debugger;
+                            } else {
+                                console.error((`${red("WATCHER FAILED TO SYNC")} ${watcher.debugName} ${magenta("DID NOT TRIGGER WATCHER")}. This means either ProxyWatcher is broken (and isn't triggering when it should, or isn't watching when it should), or ClientWatcher/PathWatcher are broken and are not properly informing callers of watchers.`), watcher.lastUnsyncedAccesses, watcher.lastUnsyncedParentAccesses, watcher.options.watchFunction);
+                                debugbreak(2);
+                                debugger;
+                            }
+                        }, 60000);
+                    }
+                    watcher.countSinceLastFullSync++;
+                    if (watcher.countSinceLastFullSync > 10) {
+                        require("debugbreak")(2);
+                        debugger;
+                        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 (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}})`;
+                        console.error(red(errorMessage));
+                        logUnsynced();
+                        result = { error: new Error(errorMessage).stack || "" };
+                        // Force the watches to be equal, so we stop looping
+                        watcher.pendingWatches.paths = new Set(watcher.lastWatches.paths);
+                        watcher.pendingWatches.parentPaths = new Set(watcher.lastWatches.parentPaths);
+                        watcher.syncRunCount++;
+                    }
+                }
+            }
+
+            return result;
+        }
+        function updateWatchers() {
+            watcher.lastWatches = {
+                paths: watcher.pendingWatches.paths,
+                parentPaths: watcher.pendingWatches.parentPaths,
+            };
+
+            // NOTE: I don't see the reason for this. How many watchers do we have that aren't watching anything? 
+            // If nothing is being watched, and nothing was... then don't bother updating the watchers
+            // if (
+            //     !initialTriggerWatch
+            //     && watcher.lastWatches.paths.size === 0 && watcher.lastWatches.parentPaths.size === 0
+            //     && watcher.pendingWatches.paths.size === 0 && watcher.pendingWatches.parentPaths.size === 0
+            // ) return;
+
+            clientWatcher.setWatches({
+                debugName: watcher.debugName,
+                // We don't need to trigger immediately, as we already ran, and if all of our values were synced
+                //  we will have already committed any results.
+                noInitialTrigger: true,
+                paths: watcher.lastWatches.paths,
+                parentPaths: watcher.lastWatches.parentPaths,
+                order: watcher.options.order,
+                orderGroup: watcher.options.orderGroup,
+                callback: trigger,
+                unwatchEventPaths(paths) {
+                    self.unwatchEventPaths(watcher, paths);
+                },
+            });
+        }
+        function commitWrites(): PathValue[] | undefined {
+            if (!options.canWrite) return undefined;
+
+            let setValues: PathValue[] | undefined;
+
+            let prefixes = options.overrideAllowLockDomainsPrefixes || getAllowedLockDomainsPrefixes();
+            // This consumes our write time, as once we write, we can't reuse writeTimes!
+            //  (If we do, it breaks dependencies).
+            let writeTime = watcher.nextWriteTime;
+            watcher.nextWriteTime = undefined;
+            if (!writeTime) {
+                writeTime = getNextTime();
+            }
+
+            if (
+                !watcher.options.hasSideEffects
+                && watcher.pendingWrites.size === 0
+                && watcher.pendingCalls.length === 0
+            ) {
+                wastedEvaluations++;
+            }
+            evaluations++;
+
+            if (watcher.pendingWrites.size > 0) {
+                let locks: ReadLock[] = [];
+                let historyBasedReads = false;
+                for (let time of watcher.pendingAccesses.keys()) {
+                    if (time === undefined) continue;
+                    // If we're reading from a specific time, and it isn't just our write time, then we're reading in the past.
+                    if (compareTime(time, writeTime) !== 0) {
+                        historyBasedReads = true;
+                        break;
+                    }
+                }
+
+                if (!watcher.options.noLocks && !watcher.options.unsafeNoLocks) {
+                    for (let [readTime, values] of watcher.pendingAccesses) {
+                        if (!readTime) {
+                            readTime = writeTime;
+                        }
+                        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;
+                            }
+                            if (!prefixes.some(x => value.path.startsWith(x))) continue;
+                            let newReadCheck = !!value.isTransparent;
+                            if (value.canGCValue && !value.isTransparent) {
+                                console.error(`Value is GCable, but not transparent. We likely forgot to set isTransparent when setting canGCValue. Path ${value.path}, value: ${String(pathValueSerializer.getPathValue(value))}`);
+                                debugbreak(2);
+                                debugger;
+                            }
+                            locks.push({
+                                path: value.path,
+                                startTime: value.time,
+                                endTime: readTime,
+                                readIsTransparent: newReadCheck,
+                            });
+                        }
+                    }
+                    for (let [readTime, paths] of watcher.pendingEpochAccesses) {
+                        if (!readTime) {
+                            readTime = writeTime;
+                        }
+                        for (let path of paths) {
+                            if (!prefixes.some(x => path.startsWith(x))) continue;
+                            locks.push({
+                                path,
+                                startTime: epochTime,
+                                endTime: readTime,
+                                readIsTransparent: true,
+                            });
+                        }
+                    }
+                }
+
+                {
+                    // Ensure our write time isn't before any of our reads (as long as we aren't running
+                    //  at a specific time).
+                    //  - We might want an option to disable this behavior? Although, I'm not sure how we would
+                    //      run in the present, but intentionally want to write in the past? This usually only
+                    //      happens if we intentionally run in the past (in which case writeTime will be set,
+                    //      so this if statement wouldn't run anyways).
+                    let fixedWriteTime = writeTime;
+                    for (let lock of locks) {
+                        if (compareTime(lock.endTime, fixedWriteTime) > 0) {
+                            fixedWriteTime = {
+                                time: addEpsilons(lock.endTime.time, 1),
+                                version: 0,
+                                creatorId: getCreatorId(),
+                            };
+                        }
+                    }
+                    if (fixedWriteTime !== writeTime) {
+                        let prevWriteTime = writeTime;
+                        writeTime = fixedWriteTime;
+                        for (let lock of locks) {
+                            if (lock.endTime === prevWriteTime) {
+                                lock.endTime = writeTime;
+                            }
+                        }
+                    }
+                }
+
+                let forcedUndefinedWrites = new Set<string>();
+                for (let [path, value] of watcher.pendingWrites) {
+                    if (value === specialObjectWriteValue) {
+                        forcedUndefinedWrites.add(path);
+                    }
+                }
+
+                let maxLocks = watcher.options.maxLocksOverride || DEFAULT_MAX_LOCKS;
+                if (locks.length > maxLocks) {
+                    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,
+                    writeTime: writeTime,
+                    locks,
+                    noWritePrediction: options.doNotStoreWritesAsPredictions,
+                    eventWrite: options.eventWrite,
+                    dryRun: options.dryRun,
+                    forcedUndefinedWrites,
+                    source: options.source,
+                    historyBasedReads,
+                });
+            }
+
+            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();
+                    call.fromProxy = watcher.debugName;
+                    logErrors(runCall(call, metadata));
+                    watcher.options.onCallCommit?.(call, metadata);
+                }
+            });
+
+            return setValues;
+
+        }
+        const hasUnsyncedBefore = measureWrap(function proxyWatchHasUnsyncedBefore() {
+            if (watcher.options.commitAllRuns) return 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)) {
+                    return true;
+                }
+            }
+            for (let path of watcher.lastUnsyncedParentAccesses) {
+                if (!authorityStorage.isParentSynced(path)) {
+                    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 false;
+        });
+        function logUnsynced() {
+            let anyLogged = false;
+            for (let path of watcher.lastUnsyncedAccesses) {
+                if (!authorityStorage.isSynced(path)) {
+                    console.log(yellow(`    Waiting for ${path}`));
+                    anyLogged = true;
+                }
+            }
+            for (let path of watcher.lastUnsyncedParentAccesses) {
+                if (!authorityStorage.isParentSynced(path)) {
+                    console.log(yellow(`    Waiting for parent ${path}`));
+                    anyLogged = true;
+                }
+            }
+            // NOTE: We don't log for promises, as they are not checked in hasUnsyncedBefore
+            return anyLogged;
+        }
+
+
+        let trigger = (changed?: WatchSpecData) => {
+            let time = Date.now();
+
+            if (this.runningWatcher) {
+                throw new Error(`Tried to trigger a nested watcher. This likely means explicitlyTrigger was called inside a callback. Instead, use a watched synced sequenceNumber, accessed in the first line of the target watcher, which is incremented when you want to re-evaluate it. Attempted nested watcher ${watcher.debugName}, triggered by ${this.runningWatcher.debugName}`);
+            }
+            if (watcher.disposed) {
+                return;
+            }
+
+            // Merge triggers. We keep triggers if a callback fails to rerun due to unsynced values. This is essential, as it allows
+            //  callbacks to always receive every changed value, which we rely on to maintain delta based dependencies.
+            {
+                if (changed && (PathValueProxyWatcher.TRACK_TRIGGERS || ClientWatcher.DEBUG_TRIGGERS || options.trackTriggers)) {
+                    if (watcher.triggeredByChanges) {
+                        for (let path of changed.paths) {
+                            watcher.triggeredByChanges.paths.add(path);
+                        }
+                        for (let parentPath of changed.newParentsSynced) {
+                            watcher.triggeredByChanges.newParentsSynced.add(parentPath);
+                        }
+                        if (changed.pathSources) {
+                            if (watcher.triggeredByChanges.pathSources) {
+                                for (let value of changed.pathSources) {
+                                    watcher.triggeredByChanges.pathSources.add(value);
+                                }
+                            } else {
+                                watcher.triggeredByChanges.pathSources = new Set(changed.pathSources);
+                            }
+                        }
+                        if (changed.extraReasons) {
+                            watcher.triggeredByChanges.extraReasons = [
+                                ...watcher.triggeredByChanges.extraReasons || [],
+                                ...changed.extraReasons
+                            ];
+                        }
+                    } else {
+                        watcher.triggeredByChanges = changed;
+                    }
+                }
+            }
+
+            triggerCount++;
+            let dropInsteadOfDelay = options.runImmediately || options.temporary;
+
+            const runOncePerPaint = options.runOncePerPaint;
+
+            if (runOncePerPaint) {
+                if (pausedUntilNextPaint.has(runOncePerPaint)) {
+                    let prevValue = pausedUntilNextPaint.get(runOncePerPaint);
+                    if (dropInsteadOfDelay) {
+                        triggersDropped++;
+                    } else if (prevValue !== PAINT_NOOP_FUNCTION) {
+                        // If the previous value was a NOOP, we aren't dropping the function, we are just delaying it
+                        triggersDropped++;
+                    }
+                    pausedUntilNextPaint.set(runOncePerPaint, () => {
+                        // Use dropInsteadOfDelay as late as possible, so it is set by the latest call,
+                        //  instead of the first call.
+                        if (dropInsteadOfDelay) return;
+                        watcher.explicitlyTrigger();
+                    });
+                    return;
+                }
+
+                // Set NOOP function just as a placeholder, to block future calls (until the next paint)
+                pausedUntilNextPaint.set(runOncePerPaint, PAINT_NOOP_FUNCTION);
+                void onNextPaint().finally(() => {
+                    let fnc = pausedUntilNextPaint.get(runOncePerPaint);
+                    if (!fnc) return;
+                    pausedUntilNextPaint.delete(runOncePerPaint);
+                    fnc();
+                });
+            }
+
+            if (!options.runImmediately && !options.allowUnsyncedReads && hasUnsyncedBefore()) {
+                if (SHOULD_TRACE) {
+                    console.log(yellow(`Skipping trigger due to unsynced watchers. ${watcher.debugName} at ${time}`), watcher.triggeredByChanges);
+                    if (!logUnsynced()) {
+                        debugbreak(2);
+                        debugger;
+                    }
+                }
+                // NOTE: When we sync the values, we will automatically be triggered, so we don't need to
+                //  setup a trigger here.
+                return;
+            }
+
+            // NOTE: We don't log the trigger evaluation starting, as that should really be logged inside of ClientWatcher,
+            //      as a result of ClientWatcher.DEBUG_TRIGGERS (except for runImmediate).
+            if (options.runImmediately) {
+                if (SHOULD_TRACE) {
+                    console.log(`${green("INITIAL TRIGGER")} ${watcher.debugName}`, watcher.triggeredByChanges);
+                }
+            }
+
+            watcher.lastEvalTime = Date.now();
+
+            // Do as little as possible while runningWatcher is true. This allows callbacks, etc, to create
+            //  new watchers without having to juggle .runningWatcher.
+            let result: { result: Result } | { error: string } | undefined;
+            try {
+                this.runningWatcher = watcher;
+                result = runWatcher();
+            } finally {
+                this.runningWatcher = undefined;
+            }
+
+            const nonLooping = options.runImmediately || options.allowUnsyncedReads;
+
+            const readyToCommit = (
+                nonLooping || getReadyToCommit()
+            );
+
+            if (!nonLooping) {
+                if (readyToCommit) {
+                    harvestableReadyLoopCount++;
+                } else {
+                    harvestableWaitingLoopCount++;
+                }
+            }
+
+            // Commit writes BEFORE we watch. This prevents us from triggering ourself, in our first watch
+            //  (on subsequent watches ClientWatcher will prevent self watches. It can't for the first
+            //  watch, as it wasn't the triggerer).
+            let values: PathValue[] | undefined;
+            if (readyToCommit) {
+                try {
+                    values = commitWrites();
+                } catch (e: any) {
+                    // setValues might throw, such as if the write time is too far into the past.
+                    result = { error: e.stack };
+                }
+            }
+
+            if (SHOULD_TRACE && "error" in result) {
+                console.log(red(`Error in watcher ${watcher.debugName} at ${time}`), result.error);
+            }
+
+            if (!options.runImmediately) {
+                updateWatchers();
+            }
+
+            if (!readyToCommit) {
+                if (SHOULD_TRACE) {
+                    console.log(yellow(`Skipping trigger commit due to unsynced accesses. ${watcher.debugName} at ${time}`), watcher.triggeredByChanges);
+                    if (watcher.lastSpecialPromiseUnsynced) {
+                        console.log(yellow(`    Waiting for promise`));
+                    }
+                    logUnsynced();
+                }
+                return;
+            }
+
+            if (SHOULD_TRACE) {
+                console.log(green(`Committing ${values?.length || 0} watcher writes ${watcher.debugName} at ${time}`), watcher.triggeredByChanges, watcher.lastUnsyncedAccesses, watcher.lastUnsyncedParentAccesses);
+            }
+
+            // ONLY clear triggeredByChanges when we have a succesful run, otherwise delta based watchers won't work!
+            watcher.triggeredByChanges = undefined;
+            options.onResultUpdated?.(result, values, watcher);
+        };
+        trigger = measureWrap(trigger, `(watcher) ${watcher.debugName}`);
+        watcher.explicitlyTrigger = trigger;
+
+        self.allWatchersLookup.set(trigger, watcher);
+
+        if (options.static) {
+            // Do nothing, this will be explicitly triggered when needed
+        } else if (options.runImmediately) {
+            trigger(undefined);
+            dispose();
+        } else {
+            // Set our watchers
+            updateWatchers();
+            clientWatcher.explicitlyTriggerWatcher(trigger, {
+                synchronous: options.synchronousInit,
+            });
+        }
+        return watcher;
+    }
+
+    /** IMPORTANT! Values written will only show up in direct parent calls.
+     *      This means if you do `data.list[Date.now()].value = value`,
+     *          getKeys(data.list) will NOT have your new key.
+     *      Instead, do writes like this: `data.list[Date.now()] = { value }`,
+     *          or, if the objects are atomic, like this: `data.list[Date.now()] = atomicObjectWrite({ value })`,
+     *          which is move efficient (but the .value cannot be mutated in the future, only clobbered).
+     *      NOTE: For reading values (readOnly), just use `commitFunction`.
+    */
+    public writeOnly<Result = void>(
+        options: Omit<WatcherOptions<Result>, "onResultUpdated" | "onWriteCommitted">
+    ): Result {
+        let result: { result: Result } | { error: string } | undefined;
+        this.createWatcher({
+            forceEqualWrites: true,
+            ...options,
+            writeOnly: true,
+            runImmediately: true,
+            allowUnsyncedReads: true,
+            canWrite: true,
+            temporary: true,
+            onResultUpdated: r => {
+                result = r;
+            }
+        });
+        if (!result) {
+            throw new Error("Expected result to be set");
+        }
+        if ("error" in result) {
+            throw errorify(result.error);
+        }
+        return result.result as Result;
+    }
+
+    public runOnce<Result = void>(
+        options: Omit<WatcherOptions<Result>, "onResultUpdated" | "onWriteCommitted">
+    ): Result {
+        let result: { result: Result } | { error: string } | undefined;
+        let watcher = this.createWatcher({
+            ...options,
+            runImmediately: true,
+            allowUnsyncedReads: true,
+            canWrite: true,
+            temporary: true,
+            onResultUpdated: r => {
+                result = r;
+            }
+        });
+        if (!result) {
+            throw new Error("Expected result to be set");
+        }
+        if ("error" in result) {
+            throw errorify(result.error);
+        }
+        if (watcher.lastUnsyncedAccesses.size > 0 || watcher.lastUnsyncedParentAccesses.size > 0) {
+            //console.warn(`One time watcher run had unsynced accesses after running once. The result will be incomplete. Run with syncing (Querysub.commit) to actually synchronize new values, ${watcher.debugName}`, watcher.options.watchFunction, watcher.lastUnsyncedAccesses, watcher.lastUnsyncedParentAccesses);
+        }
+        return result.result as Result;
+    }
+
+    /** Runs the function until all reads are synced, then disposes the watcher and returns
+     *      - Can be used just with readers, but is most useful for writers (as the
+     *          absolutely soonest we can safely write is when all reads are synced)
+     *      - "writeOnly" is a dangerous version of this, which doesn't wait, and instead
+     *          just writes immediately (but in exchange, it cannot read).
+     *  TODO: Find a way to reuse watchers with different functions. For simple functions this can be
+     *      about 4X faster. It is more difficult if the function has to wait to sync values,
+     *      but we can probably still reuse watchers in some way.
+     *      - The "static" option might help with this.
+     */
+    public async commitFunction<Result = void>(
+        options: Omit<WatcherOptions<Result>, "onResultUpdated" | "onWriteCommitted">,
+        config?: {
+            onWritesCommitted?: (writes: PathValue[]) => void;
+        }
+    ): Promise<Result> {
+        options = {
+            canWrite: true,
+            waitForIncompleteTransactions: true,
+            ...options,
+        };
+
+        if (this.runningWatcher?.options.inlineNestedWatchers) {
+            this.createWatcher(options);
+            return "Nested commitFunctions cannot return values" as any;
+        }
+
+        let onResult!: (result: Result) => void;
+        let onError!: (error: Error) => void;
+        let resultPromise = new Promise<Result>((resolve, reject) => { onResult = resolve; onError = reject; });
+        let anyWrites = false;
+        this.createWatcher({
+            ...options,
+            temporary: true,
+            onResultUpdated: (result, writes, watcher) => {
+                if (writes?.length) {
+                    anyWrites = true;
+                }
+                watcher.dispose();
+                if ("error" in result) {
+                    onError(errorify(result.error));
+                } else {
+                    onResult(result.result);
+                }
+                if (writes && config?.onWritesCommitted) {
+                    config.onWritesCommitted(writes);
+                }
+            }
+        });
+        let result = await resultPromise;
+        // NOTE: Now we ALWAYS wait, to prevent services from terminating their process before their writes finish.
+        //  It is just too hard to remember to call pathValueCommitter.waitForValuesToCommit in every service.
+        if (options.canWrite && anyWrites && !options.dryRun && !options.noWaitForCommit) {
+            await pathValueCommitter.waitForValuesToCommit();
+        }
+        return result;
+    }
+    /** Run the same as usual, but instead of committing writes, returns them. */
+    public async dryRun(
+        options: Omit<WatcherOptions<any>, "onResultUpdated" | "onWriteCommitted">
+    ): Promise<PathValue[] | undefined> {
+        let result = await this.dryRunFull(options);
+        return result.writes;
+    }
+    /** Run the same as usual, but instead of committing writes, returns them. */
+    public async dryRunFull(
+        options: Omit<WatcherOptions<any>, "onResultUpdated" | "onWriteCommitted">
+    ): Promise<DryRunResult> {
+        type Result = {
+            writes: PathValue[];
+            readPaths: Set<string>
+            readParentPaths: Set<string>;
+            result: unknown;
+        };
+        let onResult!: (result: Result) => void;
+        let onError!: (error: Error) => void;
+        let resultPromise = new Promise<Result>((resolve, reject) => { onResult = resolve; onError = reject; });
+        let watcher = this.createWatcher({
+            ...options,
+            canWrite: true,
+            dryRun: true,
+            temporary: true,
+            onResultUpdated: (result, values, watcher) => {
+                watcher.dispose();
+                if ("error" in result) {
+                    onError(errorify(result.error));
+                } else {
+                    onResult({
+                        writes: values ?? [],
+                        readPaths: new Set(watcher.pendingWatches.paths),
+                        readParentPaths: new Set(watcher.pendingWatches.parentPaths),
+                        result: result.result
+                    });
+                }
+            }
+        });
+        let result = await resultPromise;
+        return result;
+    }
+
+
+    private allWatchers = registerResource("paths|proxyWatcher.allWatchers", new Set<SyncWatcher>());
+    private allWatchersLookup = registerResource("paths|proxyWatcher.allWatchersLookup", new Map<Function, SyncWatcher>());
+    public getWatcherForTrigger(trigger: Function): SyncWatcher | undefined {
+        return this.allWatchersLookup.get(trigger);
+    }
+    public getAllWatchers(): Set<SyncWatcher> {
+        return this.allWatchers;
+    }
+    public inWatcher(): boolean {
+        return !!this.runningWatcher;
+    }
+    /** @deprecated try not to call getTriggeredWatcher, and instead try to call Querysub helper
+     *      functions. getTriggeredWatcher exposes too much of our interface, which we need
+     *      to abstact out when we rewrite proxyWatcher.
+      */
+    public getTriggeredWatcher(): SyncWatcher {
+        let watcher = this.runningWatcher;
+        if (!watcher) {
+            throw new Error("Not in a watcher");
+        }
+        return watcher;
+    }
+
+    public isAllSynced(config?: {
+        ignoreAlwaysCommitAllRunsFlag?: boolean;
+    }) {
+        if (!config?.ignoreAlwaysCommitAllRunsFlag && this.runningWatcher?.options.commitAllRuns) {
+            return true;
+        }
+        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
+     *      to abstact out when we rewrite proxyWatcher.
+      */
+    public getTriggeredWatcherMaybeUndefined(): SyncWatcher | undefined {
+        return this.runningWatcher;
+    }
+
+    /** Watches everything we were watching last watch. Is essential for efficient watching code,
+     *      which needs access to a lot of state, but doesn't want to process the entire state
+     *      every time any value changes.
+     */
+    public reuseLastWatches() {
+        let watcher = this.getTriggeredWatcher();
+        for (let path of watcher.lastUnsyncedAccesses) {
+            if (!authorityStorage.isSynced(path)) {
+                watcher.pendingUnsyncedAccesses.add(path);
+            }
+        }
+        for (let path of watcher.lastUnsyncedParentAccesses) {
+            if (!authorityStorage.isParentSynced(path)) {
+                watcher.pendingUnsyncedParentAccesses.add(path);
+            }
+        }
+
+
+        function addToSet(set1: Set<string>, set2: Set<string>) {
+            let base = set2;
+            for (let path of set1) {
+                base.add(path);
+            }
+            return base;
+        }
+
+        // NOTE: If we don't clone, then pathValueClientWatcher cannot detect changes, and we
+        //  end up staying watched on everything!
+        //  - We should really fix this though, as if we can avoid this clone, we can have really efficient
+        //      incremental watches.
+        watcher.pendingWatches.paths = addToSet(new Set(watcher.lastWatches.paths), watcher.pendingWatches.paths);
+        watcher.pendingWatches.parentPaths = addToSet(new Set(watcher.lastWatches.parentPaths), watcher.pendingWatches.parentPaths);
+    }
+
+    /** NOTE: This explicitly causes the watcher to be unsynced until function
+     *      can be evaluated without any pending promises. This makes this significantly
+     *      more powerful than waiting on localState.
+     *  NOTE: IF you don't want to cause the caller to be unsynced, use a local schema instead.
+     *      This allows callers to see what path triggered them, which is often more informative
+     *      than waitReason. It also exposes the state to any synced diagnostics tools.
+     */
+    public triggerOnPromiseFinish(
+        promise: MaybePromise<unknown>,
+        config: {
+            // For example, "waitForModuleToLoad"
+            waitReason: string;
+            // Doesn't cause us to be unsynced, instead just triggering the watcher
+            //      when the promise resolves (or rejects).
+            noWait?: boolean;
+        }
+    ) {
+        // This needs to mark the watcher as unsynced
+        if (typeof promise === "object" && promise && promise instanceof Promise) {
+            let watcher = this.getTriggeredWatcher();
+            if (!config.noWait) {
+                watcher.specialPromiseUnsynced = true;
+            }
+            watcher.lastSpecialPromiseUnsyncedReason = config.waitReason;
+            void promise.finally(() => {
+                watcher.explicitlyTrigger({
+                    paths: new Set(),
+                    newParentsSynced: new Set(),
+                    pathSources: new Set(),
+                    extraReasons: [getPathStr2(`Promise`, config.waitReason || "")]
+                });
+            });
+        }
+    }
+
+    public setEventPath(getValue: () => unknown) {
+        let path = getProxyPath(getValue);
+        let watcher = this.getTriggeredWatcher();
+        watcher.pendingEventWrites.add(path);
+    }
+    public unwatchEventPaths(watcher: SyncWatcher, paths: Set<string>) {
+        for (let path of paths) {
+            watcher.lastWatches.paths.delete(path);
+            watcher.lastWatches.parentPaths.delete(path);
+            watcher.pendingWatches.paths.delete(path);
+            watcher.pendingWatches.parentPaths.delete(path);
+            watcher.pendingUnsyncedAccesses.delete(path);
+            watcher.pendingUnsyncedParentAccesses.delete(path);
+        }
+    }
+
+    public debug_breakOnWrite(proxy: string | unknown | (() => unknown)) {
+        let path = this.getPathAndWatch(proxy);
+        if (!path) {
+            console.error(`Value is not a proxy, and so cannot get path. Either pass a proxy, or a getter for a value.`);
+            return;
+        }
+        PathValueProxyWatcher.BREAK_ON_WRITES.add(path);
+    }
+    public debug_logOnWrite(proxy: unknown | (() => unknown)) {
+        let path = this.getPathAndWatch(proxy);
+        if (!path) {
+            console.error(`Value is not a proxy, and so cannot get path. Either pass a proxy, or a getter for a value.`);
+            return;
+        }
+        PathValueProxyWatcher.LOG_WRITES_INCLUDES.add(path);
+    }
+    public getPathNoWatch(proxy: string | unknown | (() => unknown)) {
+        return typeof proxy === "function" ? getProxyPath(proxy as any) : getPathFromProxy(proxy);
+    }
+    public getPathAndWatch(proxy: string | unknown | (() => unknown)) {
+        if (typeof proxy === "string") {
+            return proxy;
+        }
+
+        // Prefer to call the function, as if the result is a proxy we want the path of that,
+        //  instead of the path the proxy is inside of!
+        if (typeof proxy === "function") {
+            return getPathFromProxy(proxy()) || getProxyPathAndWatch(proxy as any);
+        }
+        return getPathFromProxy(proxy);
+    }
+
+    public ignoreWatches<T>(code: () => T) {
+        return doProxyOptions({ noSyncing: true }, code);
+    }
+}
+
+const PAINT_NOOP_FUNCTION = () => { };
+let pausedUntilNextPaint = new Map<string, () => void>();
+
+// gitHash => domainName => moduleId => schema
+let schemas = new Map<string, Map<string, Map<string, Schema2>>>();
+
+
+// NOTE: We hardcode knowledge of how module data is nested to handle schemas. This... isn't great,
+//  but it makes the code faster, and if we change how module data is nested it will break
+//  all existing data anyways, so... I don't think we ever will.
+// Path pattern is: [domain, "PathFunctionRunner", moduleId, "Data"]
+export const getMatchingSchema = cacheLimited(1000, function getMatchingSchema(pathStr: string): {
+    schema: Schema2;
+    nestedPath: string[];
+} | undefined {
+    if (_noAtomicSchema) return undefined;
+    let base = getBaseMatchingSchema(pathStr);
+    if (base) return base;
+    let prefix = getPrefixMatchingSchema(pathStr);
+    if (prefix) return prefix;
+    return undefined;
+});
+function getBaseMatchingSchema(pathStr: string): {
+    schema: Schema2;
+    nestedPath: string[];
+} | undefined {
+    let schemaForHash = (
+        schemas.get(getCurrentCallObj()?.fnc.gitRef || "ambient")
+        // Default to the ambient schema for clientside calls.
+        || schemas.get("ambient")
+    );
+
+    if (_noAtomicSchema) return undefined;
+    if (getPathIndex(pathStr, 3) !== "Data") return undefined;
+    let domain = getPathIndex(pathStr, 0)!;
+    let moduleId = getPathIndex(pathStr, 2)!;
+    let schema = schemaForHash?.get(domain)?.get(moduleId);
+    if (!schema) return undefined;
+    let nestedPathStr = getPathSuffix(pathStr, 4);
+    let nestedPath = getPathFromStr(nestedPathStr);
+    return { schema, nestedPath };
+}
+
+export function registerSchema(config: {
+    schema: Schema2;
+    domainName: string;
+    moduleId: string;
+    gitHash: string;
+}) {
+    getMatchingSchema.clear();
+
+    const { schema, domainName, moduleId, gitHash } = config;
+    let gitSchemas = schemas.get(gitHash);
+    if (!gitSchemas) {
+        schemas.set(gitHash, gitSchemas = new Map());
+    }
+
+    let domainSchemas = gitSchemas.get(domainName);
+    if (!domainSchemas) {
+        gitSchemas.set(domainName, domainSchemas = new Map());
+    }
+    domainSchemas.set(moduleId, schema);
+}
+
+export let schemaPrefixes: { len: number; prefixes: Map<string, Schema2> }[] = [];
+export function registerSchemaPrefix(config: {
+    schema: Schema2;
+    prefixPathStr: string;
+}) {
+    let len = getPathDepth(config.prefixPathStr);
+    let list = schemaPrefixes.find(x => x.len === len);
+    if (!list) {
+        schemaPrefixes.push(list = { len, prefixes: new Map() });
+    }
+    if (isNode() && !globalThis.isHotReloading?.() && !isDynamicallyLoading()) {
+        if (list.prefixes.has(config.prefixPathStr)) {
+            throw new Error(`Prefix matches only work due to only having one version of the code ever load (except for during hot reloading development clientside). If we try to render multiple versions of the same code serverside (ex, because we pre-loaded new code during a deploy), it will break, as we can't distinguish them. ADD GIT HASH TO PREFIX SCHEMAS TO FIX THIS! Tried to double load ${config.prefixPathStr}`);
+        }
+    }
+    list.prefixes.set(config.prefixPathStr, config.schema);
+}
+export function unregisterSchemaPrefix(config: {
+    schema: Schema2;
+    prefixPathStr: string;
+}) {
+    let len = getPathDepth(config.prefixPathStr);
+    let list = schemaPrefixes.find(x => x.len === len);
+    if (!list) return;
+    list.prefixes.delete(config.prefixPathStr);
+}
+function getPrefixMatchingSchema(pathStr: string): {
+    schema: Schema2;
+    nestedPath: string[];
+} | undefined {
+    let len = getPathDepth(pathStr);
+    for (let list of schemaPrefixes) {
+        if (len < list.len) continue;
+        let prefix = getPathPrefix(pathStr, list.len);
+        let schema = list.prefixes.get(prefix);
+        if (schema) {
+            let nestedPath = getPathFromStr(getPathSuffix(pathStr, list.len));
+            return { schema, nestedPath };
+        }
+    }
+    return undefined;
+}
+
+
+let _noAtomicSchema = false;
+export function noAtomicSchema<T>(code: () => T) {
+    let prev = _noAtomicSchema;
+    _noAtomicSchema = true;
+    try {
+        return code();
+    } finally {
+        _noAtomicSchema = prev;
+    }
+}
+
+
+export const proxyWatcher = new PathValueProxyWatcher();
+if ((globalThis as any).proxyWatcher) {
+    debugger;
+    console.error(`Loaded PathValueProxyWatcher twice. This will break this. In ${module.filename}`);
+}
+(globalThis as any).proxyWatcher = proxyWatcher;
+(globalThis as any).ProxyWatcher = PathValueProxyWatcher;
+// Probably the most useful debug function for debugging watch based functions.
+(globalThis as any).getCurrentTriggers = function () {
+    return proxyWatcher.getTriggeredWatcher().triggeredByChanges;
+};
+(globalThis as any).getAllWatchers = function () {
+    return proxyWatcher.getAllWatchers();
+};
+
+registerPeriodic(function checkForZombieWatches() {
+    let now = Date.now();
+    const threshold = 30 * 1000;
+    function isZombieWatch(watcher: SyncWatcher) {
+        if (watcher.options.static) return false;
+        if (!watcher.hasAnyUnsyncedAccesses()) return false;
+        let timeSinceLastSync = now - watcher.lastSyncTime;
+        if (timeSinceLastSync < threshold) return false;
+        return true;
+    }
+
+    let zombies = Array.from(proxyWatcher.getAllWatchers()).filter(isZombieWatch);
+    lastZombieCount = zombies.length;
+    if (zombies.length > 0) {
+        let namesSet = new Set(zombies.map(x => x.debugName));
+        console.warn(`Found ${zombies.length} zombie watchers`, { names: Array.from(namesSet) });
+    }
+});
+
+
+let evaluations = 0;
+let wastedEvaluations = 0;
+
+registerMeasureInfo(() => {
+    if (evaluations === 0) return undefined;
+    let current = wastedEvaluations / evaluations;
+    wastedEvaluations = 0;
+    evaluations = 0;
+    return `${formatPercent(current)} NOOP triggers`;
+});
+
+
+let triggerCount = 0;
+let triggersDropped = 0;
+registerMeasureInfo(() => {
+    if (triggerCount === 0) return undefined;
+    let current = triggersDropped / triggerCount;
+    triggersDropped = 0;
+    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'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}`],
+            });
+        }
+    }
+);
+export 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;
+}
+
+
+registerPeriodic(function logWatcherTypes() {
+    let allWatchers = proxyWatcher.getAllWatchers();
+    let counts = new Map<string, { count: number; }>();
+    for (let watcher of allWatchers) {
+        let type = watcher.debugName.split("|")[0] || "no debug name";
+        let countObj = counts.get(type);
+        if (!countObj) {
+            countObj = { count: 0 };
+            counts.set(type, countObj);
+        }
+        countObj.count++;
+    }
+    let sorted = sort(Array.from(counts.entries()), x => -x[1].count);
+
+    console.log(`${formatNumber(allWatchers.size)} watchers | ${formatNumber(sorted.length)} types | remember, components have 3 watchers`);
+    // Log the top 5
+    for (let [type, countObj] of sorted.slice(0, 5)) {
+        let countText = `${formatPercent(countObj.count / allWatchers.size)} (${formatNumber(countObj.count)})`;
+        console.log(`    ${countText.padEnd(15, " ")}    ${type}`);
+    }
+});
+
+// #endregion Proxy Ordering
+
+import { inlineNestedCalls } from "../3-path-functions/syncSchema"; import { LOCAL_DOMAIN_PATH } from "../0-path-value-core/PathRouter";
+import { waitIfReceivedIncompleteTransaction } from "./TransactionDelayer";
+