querysub 0.2.0

package/src/2-proxy/PathValueProxyWatcher.ts

@@ -0,0 +1,1857 @@
+import { measureCode, measureWrap } from "socket-function/src/profiling/measure";
+import { SocketFunction } from "socket-function/SocketFunction";
+import { deepCloneJSON, getKeys, isNode, recursiveFreeze, timeInMinute } 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 { lazy } from "socket-function/src/caching";
+import { delay, 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, getProxyPath, isValueProxy, isValueProxy2 } from "./pathValueProxy";
+import { authorityStorage, compareTime, ReadLock, epochTime, getNextTime, MAX_ACCEPTED_CHANGE_AGE, PathValue, Time, getCreatorId } from "../0-path-value-core/pathValueCore";
+import { runCodeWithDatabase, rawSchema } from "./pathDatabaseProxyBase";
+import { CallSpec, DEPTH_TO_DATA, MODULE_INDEX, getCurrentCall } from "../3-path-functions/PathFunctionRunner";
+import { interceptCalls, runCall } from "../3-path-functions/PathFunctionHelpers";
+import { LOCAL_DOMAIN } from "../0-path-value-core/PathController";
+import debugbreak from "debugbreak";
+import { FunctionMetadata, getSchemaObject, inlineNestedCalls } from "../3-path-functions/syncSchema";
+import { pathValueCommitter } from "../0-path-value-core/PathValueController";
+import { pathValueSerializer } from "../-h-path-value-serialize/PathValueSerializer";
+import { isClient } from "../config2";
+import { isDeploy } from "../3-path-functions/deployCheck";
+import { LOCAL_DOMAIN_PATH } from "../0-path-value-core/NodePathAuthorities";
+import { PermissionsCheck } from "../4-querysub/permissions";
+import { registerPeriodic } from "../diagnostics/periodic";
+import { remoteWatcher } from "../1-path-client/RemoteWatcher";
+import { Schema2, Schema2Fncs } from "./schema2";
+import { getDomain } from "../config";
+import { Querysub } from "../4-querysub/QuerysubController";
+
+// 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).
+
+let nextOrderSeqNum = 1;
+
+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;
+
+    /** 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;
+
+    watchFunction: () => Result;
+
+    // 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;
+
+    /** 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;
+
+    /** 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 ClientWatcher.DEBUG_SOURCES
+    // Sometimes we need trigger tracking for delta watchers, so this isn't just for debugging
+    trackTriggers?: boolean;
+}
+
+const startTime = Date.now();
+
+//  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 [getPathStr1(LOCAL_DOMAIN)];
+    }
+};
+
+export type SyncWatcher = {
+    options: WatcherOptions<any>;
+
+    dispose: () => void;
+    disposed?: boolean;
+    // Reset every time the inner function is run, so that inner callbacks can know when the dispose
+    //  happens, without having to dedupe their callback function.
+    onInnerDisposed: (() => 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>>;
+    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 }[];
+}
+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;
+(global 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";
+// 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...
+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; };
+};
+
+
+const specialObjectWriteDepth = lazy(() => {
+    if (isDeploy()) return MODULE_INDEX;
+    return DEPTH_TO_DATA;
+});
+
+class SyncWatcherTag { }
+
+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;
+
+    private SHOULD_TRACE(watcher: SyncWatcher) {
+        return PathValueProxyWatcher.DEBUG || PathValueProxyWatcher.TRACE || PathValueProxyWatcher.TRACE_WRITES && watcher.options.canWrite || ClientWatcher.DEBUG_TRIGGERS === "heavy";
+    }
+
+    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) {
+            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 && !PermissionsCheck.skippingChecks) {
+            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);
+        // 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);
+            }
+            readValues.set(pathValue.path, pathValue);
+        }
+
+        return pathValue;
+    };
+    public getCallback = (pathStr: string, syncParentKeys?: "parentKeys", readTransparent?: "readTransparent"): { value: unknown } | undefined => {
+        if (PathValueProxyWatcher.BREAK_ON_READS.size > 0 && proxyWatcher.isAllSynced()) {
+            if (PathValueProxyWatcher.BREAK_ON_READS.has(pathStr)) {
+                debugger;
+            }
+        }
+        const watcher = this.runningWatcher;
+        if (!watcher) {
+            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 (PathValueProxyWatcher.BREAK_ON_WRITES.has(pathStr)) {
+                debugger;
+            }
+        }
+
+        if (PathValueProxyWatcher.SET_FUNCTION_WATCH_ON_WRITES.size > 0 && proxyWatcher.isAllSynced()) {
+            if (PathValueProxyWatcher.SET_FUNCTION_WATCH_ON_WRITES.has(pathStr)) {
+                PathValueProxyWatcher.BREAK_ON_CALL.add(
+                    getPathStr2(getCurrentCall().ModuleId, getCurrentCall().FunctionId)
+                );
+            }
+        }
+
+        if (PathValueProxyWatcher.LOG_WRITES_INCLUDES.size > 0 && proxyWatcher.isAllSynced()) {
+            for (let log of PathValueProxyWatcher.LOG_WRITES_INCLUDES) {
+                if (pathStr.includes(log)) {
+                    console.log(`Write path "${pathStr}" = ${value}`);
+                }
+            }
+        }
+
+        // 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;
+            }
+            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;
+                while (true) {
+                    parentPathStr = getParentPathStr(parentPathStr);
+                    if (getPathDepth(parentPathStr) < specialObjectWriteDepth()) 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 {
+            watcher.pendingWrites.set(pathStr, value);
+        }
+    };
+    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) {
+            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 keys: string[] = [];
+        let childPaths = authorityStorage.getPathsFromParent(pathStr);
+        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.push(key);
+                }
+            }
+        }
+
+        // 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).
+        keys.sort();
+
+        return keys;
+    };
+
+    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 {
+        // 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(...)`.
+        if (options.runImmediately && this.runningWatcher) {
+            // 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()
+                    );
+                    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 timeSinceStart = Date.now() - startTime;
+                // // If we JUST started, we are just clearing out old function calls, so don't break on the error
+                // //  (Run leeway time + 60s)
+                // if (timeSinceStart > 1000 * 60 + runLeeway) {
+                //     debugbreak(2);
+                //     debugger;
+                // }
+                let message = `MAX_CHANGE_AGE_EXCEEDED! Cannot run watcher 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 watcher: SyncWatcher = {
+            debugName: options.debugName || options.watchFunction.name || options.watchFunction.toString().replaceAll("\n", "\\n").replaceAll(/ +/g, " ").slice(0, 50),
+            dispose: () => { },
+            disposed: false,
+            onInnerDisposed: [],
+            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: [],
+        };
+        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);
+
+        const baseFunction = measureWrap(options.watchFunction, watcher.debugName);
+
+        watcher.setCurrentReadTime = (time, code) => {
+            let prev = watcher.currentReadTime;
+            watcher.currentReadTime = time;
+            try {
+                return code();
+            } finally {
+                watcher.currentReadTime = prev;
+            }
+        };
+        watcher.hasAnyUnsyncedAccesses = () => {
+            return watcher.pendingUnsyncedAccesses.size > 0 || watcher.pendingUnsyncedParentAccesses.size > 0 || watcher.specialPromiseUnsynced;
+        };
+
+        function dispose() {
+            watcher.disposed = true;
+            clientWatcher.unwatch(trigger);
+            self.allWatchers.delete(watcher);
+            let disposeCallbacks = watcher.onInnerDisposed;
+            watcher.onInnerDisposed = [];
+            for (let callback of disposeCallbacks) {
+                logErrors(((async () => { await callback(); }))());
+            }
+        }
+        function runWatcher() {
+            watcher.pendingWrites.clear();
+            watcher.pendingEventWrites.clear();
+            watcher.pendingCalls = [];
+            watcher.pendingWatches.paths.clear();
+            watcher.pendingWatches.parentPaths.clear();
+            watcher.pendingUnsyncedAccesses.clear();
+            watcher.pendingUnsyncedParentAccesses.clear();
+
+            watcher.pendingAccesses.clear();
+            watcher.pendingEpochAccesses.clear();
+            watcher.onInnerDisposed = [];
+
+            // 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;
+                if (handling === "inline") {
+                    rawResult = inlineNestedCalls(() => {
+                        return authorityStorage.temporaryOverride(options.overrides, () =>
+                            runCodeWithDatabase(proxy, baseFunction)
+                        );
+                    });
+                } else {
+                    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)) {
+                                    debugger;
+                                }
+                            }
+                            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) {
+                                watcher.pendingCalls.push({ call, metadata });
+                            } else if (handling === "ignore") {
+                            } else {
+                                let unhandled: never = handling;
+                                throw new Error(`Invalid handling type ${handling}`);
+                            }
+                        },
+                        code() {
+                            return authorityStorage.temporaryOverride(options.overrides, () =>
+                                runCodeWithDatabase(proxy, baseFunction)
+                            );
+                        },
+                    });
+                }
+
+                // We use atomic object read, as our callers don't want a proxy.
+                //  If they want to get a full object, they will have to destructure it themselves
+                //  (as for us to destructure it would require further synchronization, which...
+                //  is just annoying, and so we won't implement that unless it becomes very useful).
+                //  (Also, if the result is a proxy is confuses promises into thinking it is another promise,
+                //  which is annoying).
+                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 {
+                // 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;
+            }
+
+            watcher.lastUnsyncedAccesses = watcher.pendingUnsyncedAccesses;
+            watcher.lastUnsyncedParentAccesses = watcher.pendingUnsyncedParentAccesses;
+            watcher.lastSpecialPromiseUnsynced = watcher.specialPromiseUnsynced;
+            const specialPromiseUnsynced = watcher.specialPromiseUnsynced;
+            watcher.specialPromiseUnsynced = false;
+
+            if (!watcher.options.static) {
+                if (!watcher.hasAnyUnsyncedAccesses()) {
+                    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;
+                            console.warn(red(`Did not sync ${watcher.debugName} after 15 seconds. Either we had a lot synchronous block, or we will never received the values we are waiting for.`), watcher.lastUnsyncedAccesses, watcher.lastUnsyncedParentAccesses, watcher.options.watchFunction);
+                        }, 15000);
+                        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 > 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 to sync with different values. If you are reading in a loop, make sure to read all the values, instead of aborting the loop if a value is not synced. ALSO, make sure you don't access paths with Math.random() or Date.now(). This will prevent the sync loop from ever stabilizing.`;
+                        if (specialPromiseUnsynced) {
+                            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!)`;
+                        }
+                        console.error(red(errorMessage));
+                        result = { error: new Error(errorMessage).stack || "" };
+                        // Force the watches to be equal, so we stop looping
+                        watcher.pendingWatches = watcher.lastWatches;
+                        watcher.syncRunCount++;
+                    }
+                }
+            }
+
+            return result;
+        }
+        function updateWatchers(initialTriggerWatch?: boolean) {
+            // 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;
+
+            watcher.lastWatches = watcher.pendingWatches;
+            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.pendingWrites.size > 0) {
+                let locks: ReadLock[] = [];
+
+                if (!watcher.options.noLocks && !watcher.options.unsafeNoLocks) {
+                    for (let [readTime, values] of watcher.pendingAccesses) {
+                        if (!readTime) {
+                            readTime = writeTime;
+                        }
+                        for (let value of values.values()) {
+                            // 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 oldReadCheck = !!(
+                                value.canGCValue
+                                || pathValueSerializer.getPathValue(value) === specialObjectWriteValue
+                            );
+                            let newReadCheck = !!value.isTransparent;
+                            if (oldReadCheck !== newReadCheck) {
+                                // IMPORTANT! IF WE HIT THIS ASSERT, DEBUG IT RIGHT NOW!
+                                //  - I updated the read check to use isTransparent. BUT... I'm not sure
+                                //      this is correct. This WILL break if we add any new isTransparent values,
+                                //      so this update is requried, but... this code is so old, that I'm not
+                                //      sure updating it like this is safe.
+                                //  - Double check the the value at `pathValueSerializer.getPathValue(value)`
+                                //      and value, and see if it should act as a tranparent value or not.
+                                debugbreak(2);
+                                debugger;
+                            }
+                            locks.push({
+                                path: value.path,
+                                startTime: value.time,
+                                endTime: readTime,
+                                readIsTranparent: 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,
+                                readIsTranparent: 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);
+                    }
+                }
+
+                setValues = clientWatcher.setValues({
+                    values: watcher.pendingWrites,
+                    eventPaths: watcher.pendingEventWrites,
+                    writeTime: writeTime,
+                    locks,
+                    noWritePrediction: options.doNotStoreWritesAsPredictions,
+                    eventWrite: options.eventWrite,
+                    dryRun: options.dryRun,
+                    forcedUndefinedWrites,
+                });
+            }
+
+            // TODO: Maybe return this in some way, so dryRun can know what calls we want to call?
+            for (let { call, metadata } of watcher.pendingCalls) {
+                // The calls have to happen after our local writes. This is because they are likely to
+                //  influence the local writes, and we don't want our local writes to be always invalidated
+                call.runAtTime = getNextTime();
+                logErrors(runCall(call, metadata));
+            }
+
+            return setValues;
+
+        }
+        const hasUnsyncedBefore = measureWrap(function proxyWatchHasUnsyncedBefore() {
+            // NOTE: We COULD remove any synced values, however... we will generally sync all values at once,
+            //      so we don't really need to optimize the cascading case here. Also... deleting values
+            //      requires cloning while we iterate, as well as mutating the set, which probably makes the
+            //      non-cascading case slower.
+            let anyUnsynced = false;
+            for (let path of watcher.lastUnsyncedAccesses) {
+                if (!authorityStorage.isSynced(path)) {
+                    anyUnsynced = true;
+                }
+            }
+            for (let path of watcher.lastUnsyncedParentAccesses) {
+                if (!authorityStorage.isParentSynced(path)) {
+                    anyUnsynced = true;
+                }
+            }
+            // NOTE: We don't check promises as they often access non-synced code, and so we might retrigger
+            //      and not use the same promise, so it might be wrong to check them.
+            return anyUnsynced;
+        });
+        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 && (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;
+                    }
+                }
+            }
+
+            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;
+                    }
+                }
+                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 readyToCommit = (
+                options.runImmediately || options.allowUnsyncedReads || (
+                    watcher.lastUnsyncedAccesses.size === 0
+                    && watcher.lastUnsyncedParentAccesses.size === 0
+                    && !watcher.lastSpecialPromiseUnsynced
+                )
+            );
+            // 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);
+            }
+
+            // 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;
+
+        if (options.static) {
+            // Do nothing, this will be explicitly triggered when needed
+        } else if (options.runImmediately) {
+            trigger(undefined);
+            dispose();
+        } else {
+            // Set our watchers
+            updateWatchers(true);
+            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,
+            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,
+            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> {
+        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({
+            canWrite: true,
+            ...options,
+            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) {
+            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<{
+        writes: PathValue[];
+        readPaths: Set<string>
+        readParentPaths: Set<string>;
+        result: unknown;
+    }> {
+        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; });
+        this.createWatcher({
+            ...options,
+            canWrite: true,
+            dryRun: 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
+                    });
+                }
+            }
+        });
+        return await resultPromise;
+    }
+
+
+    private allWatchers = registerResource("paths|proxyWatcher.allWatchers", new Set<SyncWatcher>());
+    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() {
+        return !this.getTriggeredWatcher().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;
+    }
+
+    /** 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);
+        }
+    }
+}
+
+// domainName => moduleId => schema
+let schemas = new 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"]
+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 {
+    //todonext
+    //  So... the current call, need to register the hash used for the call. This needs to be
+    //      used to prefer that schema from that same hash.
+    //      - And if we ever do cross repo calls... we need to store multiple hashes in the call
+    //          (or cascade hashes, etc, but we need to know all the hashes, and then use them here!)
+    //todonext;
+    // Ah, it's not quite so easy. So... pathFunctionLoader knows the hash on load (or that it's local),
+    //      but this information is not maintained when we are making the call (writeFunctionCall). BUT,
+    //      when we are in the call (unless it's a test call), we just called getModuleFromConfig
+    //      so we aren't too far away from knowing the hash, and passing it on.
+    //      - I think... we should return the hash, and then request it in overrideCurrentCall?
+    //todonext;
+    // Permissions checks are annoying, but... they DO call getModuleFromConfig at some time.
+    // ONLY managementPages.tsx does not actually have a module.
+    //todonext;
+    // Oh, it looks like managementPages.tsx can't operate the way it does. Hmm...
+
+    if (_noAtomicSchema) return undefined;
+    if (getPathIndex(pathStr, 3) !== "Data") return undefined;
+    let domain = getPathIndex(pathStr, 0)!;
+    let moduleId = getPathIndex(pathStr, 2)!;
+    let schema = schemas.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;
+}) {
+    //todonext
+    //  Require passing the module information here
+
+    let domainSchemas = schemas.get(config.domainName);
+    if (!domainSchemas) {
+        schemas.set(config.domainName, domainSchemas = new Map());
+    }
+    domainSchemas.set(config.moduleId, config.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() });
+    }
+    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();
+(global as any).proxyWatcher = proxyWatcher;
+// Probably the most useful debug function for debugging watch based functions.
+(global as any).getCurrentTriggers = function () {
+    return proxyWatcher.getTriggeredWatcher().triggeredByChanges;
+};
+(global 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);
+    if (zombies.length > 0) {
+        console.warn(red(`Found ${zombies.length} zombie watchers`));
+        let namesSet = new Set(zombies.map(x => x.debugName));
+        let topNames = Array.from(namesSet).slice(0, 5);
+        for (let name of topNames) {
+            console.warn(red(`    ${name}`));
+        }
+        if (namesSet.size > topNames.length) {
+            console.warn(red(`    ... and ${namesSet.size - topNames.length} more`));
+        }
+    }
+});