querysub 0.185.0 → 0.187.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.185.0",
+  "version": "0.187.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
@@ -54,4 +54,4 @@
   "resolutions": {
     "node-forge": "https://github.com/sliftist/forge#e618181b469b07bdc70b968b0391beb8ef5fecd6"
   }
-}
+}

package/spec.txt

@@ -51,6 +51,7 @@ More corruption resistance files
             - Value types will be string, float64, byte, Buffer[]
                 - and... we might as well add support for short, int, float, and uint (uint is a good way to store a guid, via storing 8 uint variables).
 
+
 Schema/binary PathValues accesses
 
     Base code

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

@@ -461,7 +461,7 @@ class PathValueCommitter {
         // NOTE: specialInitialParentCausedRejections is a bit dangerous, because it can reject golden values.
         //  This means we have to ingest it immediately, otherwise authorityStorage might gc path values
         //  (that are before a golden value), when rejections might remove that golden value.
-        if (specialInitialParentCausedRejections) {
+        if (specialInitialParentCausedRejections?.length) {
             this.ingestValidStates(specialInitialParentCausedRejections);
         }
 

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

@@ -34,13 +34,15 @@ export function getLogHistoryIncludes(includes: string) {
         return Object.values(x.values).some(y => String(y).includes(includes));
     });
 }
-(globalThis as any).getLogHistoryEquals = getLogHistoryEquals;
-(globalThis as any).getPathAuditLogs = getLogHistoryEquals;
+(globalThis as any).auditPath = getLogHistoryIncludes;
+(globalThis as any).auditValue = getLogHistoryIncludes;
 export function getLogHistoryEquals(value: string) {
     return logHistory.getAllUnordered().filter(x => {
         return Object.values(x.values).some(y => y === value);
     });
 }
+(globalThis as any).getLogHistoryEquals = getLogHistoryEquals;
+(globalThis as any).getPathAuditLogs = getLogHistoryEquals;
 
 export function auditLog(type: string, values: { [key: string]: unknown }) {
     debugLogFnc(type, values);

package/src/1-path-client/RemoteWatcher.ts

@@ -128,15 +128,19 @@ export class RemoteWatcher {
     public watchLatest(config: WatchConfig & { debugName?: string }) {
         logErrors(this.watchLatestPromise(config));
     }
+    // IMPORTANT! If this shows up as being slow in a profile, try again with devtools closed! It is often slow because async calls are many times slower when devtools is open...
     // NOTE: This is private, as who wants to wait for watch to finish?
     //      1) The value won't be ready when it finishes.
     //      2) If it errors out, they can't do anything to fix the error
     //      3) We retry internally anyways
     private watchLatestPromise(config: WatchConfig & { debugName?: string }) {
-        // NOTE: If none of the values are remote... early out. This has been profile to save a bit of time,
+        // NOTE: If none of the values are remote... early out. This has been profiled to save a bit of time,
         //  mostly due to avoiding the async call.
-        if (config.parentPaths.length === 0 && config.paths.every(x => pathValueAuthority2.isSelfAuthority(x))) {
-            return;
+        if (config.parentPaths.length === 0) {
+            let isSelf = measureBlock(() => config.paths.every(x => pathValueAuthority2.isSelfAuthority(x)), "RemoteWatcher()|watchLatestPromise|isSelfCheck");
+            if (isSelf) {
+                return;
+            }
         }
         return this.watchLatestBase(config);
     }

package/src/1-path-client/pathValueClientWatcher.ts

@@ -440,6 +440,7 @@ export class ClientWatcher {
         this.allWatchers.delete(callback);
     }
 
+    @measureFnc
     private updateUnwatches(watchSpec: WatchSpec) {
         const { callback, paths, parentPaths } = watchSpec;
         let prevSpec = this.allWatchers.get(callback);
@@ -488,14 +489,15 @@ export class ClientWatcher {
         watchSpec = prevSpec;
 
         let expiryTime = Date.now() + ClientWatcher.WATCH_STICK_TIME;
-        if (isDevDebugbreak()) {
-            for (let path of fullyUnwatchedPaths) {
-                auditLog("clientWatcher UNWATCH", { path });
-            }
-            for (let path of fullyUnwatchedParents) {
-                auditLog("clientWatcher UNWATCH PARENT", { path });
-            }
-        }
+        // Commented out, as this is showing up as a bit slow in profiling
+        // if (isDevDebugbreak()) {
+        //     for (let path of fullyUnwatchedPaths) {
+        //         auditLog("clientWatcher UNWATCH", { path });
+        //     }
+        //     for (let path of fullyUnwatchedParents) {
+        //         auditLog("clientWatcher UNWATCH PARENT", { path });
+        //     }
+        // }
         for (let path of fullyUnwatchedPaths) {
             this.pendingUnwatches.set(path, expiryTime);
         }
@@ -550,35 +552,39 @@ export class ClientWatcher {
         this.updateUnwatches(watchSpec);
 
         this.allWatchers.set(callback, watchSpec);
-        for (let path of paths) {
-            let watchers = this.valueFunctionWatchers.get(path);
-            if (!watchers) {
-                watchers = new Map();
-                this.valueFunctionWatchers.set(path, watchers);
-            }
-            watchers.set(callback, watchSpec);
-            this.pendingUnwatches.delete(path);
-        }
-        for (let path of parentPaths) {
-            let basePath = hack_stripPackedPath(path);
-            let watchersBase = this.parentValueFunctionWatchers.get(basePath);
-            if (!watchersBase) {
-                watchersBase = new Map();
-                this.parentValueFunctionWatchers.set(basePath, watchersBase);
+        measureBlock(() => {
+            for (let path of paths) {
+                let watchers = this.valueFunctionWatchers.get(path);
+                if (!watchers) {
+                    watchers = new Map();
+                    this.valueFunctionWatchers.set(path, watchers);
+                }
+                watchers.set(callback, watchSpec);
+                this.pendingUnwatches.delete(path);
             }
-            let watchers = watchersBase.get(path);
-            if (!watchers) {
-                let range = decodeParentFilter(path) || { start: 0, end: 1 };
-                watchers = {
-                    start: range.start,
-                    end: range.end,
-                    lookup: new Map()
-                };
-                watchersBase.set(path, watchers);
+        }, "ClientWatcher()|setWatches|paths");
+        measureBlock(() => {
+            for (let path of parentPaths) {
+                let basePath = hack_stripPackedPath(path);
+                let watchersBase = this.parentValueFunctionWatchers.get(basePath);
+                if (!watchersBase) {
+                    watchersBase = new Map();
+                    this.parentValueFunctionWatchers.set(basePath, watchersBase);
+                }
+                let watchers = watchersBase.get(path);
+                if (!watchers) {
+                    let range = decodeParentFilter(path) || { start: 0, end: 1 };
+                    watchers = {
+                        start: range.start,
+                        end: range.end,
+                        lookup: new Map()
+                    };
+                    watchersBase.set(path, watchers);
+                }
+                watchers.lookup.set(callback, watchSpec);
+                this.pendingParentUnwatches.delete(path);
             }
-            watchers.lookup.set(callback, watchSpec);
-            this.pendingParentUnwatches.delete(path);
-        }
+        }, "ClientWatcher()|setWatches|parentPaths");
 
         // Audit code to check if we failed to correctly maintain our paths
         //  OR (more likely), the watcher mutated the paths Set, which breaks our watching
@@ -604,27 +610,33 @@ export class ClientWatcher {
         }
         */
 
-        let pathsArray = Array.from(paths);
-        let parentPathsArray = Array.from(parentPaths);
+        let pathsArray!: string[];
+        let parentPathsArray!: string[];
+        measureBlock(() => {
+            pathsArray = Array.from(paths);
+            parentPathsArray = Array.from(parentPaths);
+        }, "ClientWatcher()|setWatches|Array.from");
         let debugName = watchSpec.callback.name;
 
         if (pathsArray.length === 0 && parentPathsArray.length === 0) {
             return;
         }
 
-        // Watch it locally as well, so when we get the value we know to trigger the client callback
-        pathWatcher.watchPath({
-            callback: getOwnNodeId(),
-            paths: pathsArray,
-            parentPaths: parentPathsArray,
-            debugName,
-            noInitialTrigger: watchSpec.noInitialTrigger,
-        });
-        remoteWatcher.watchLatest({
-            paths: pathsArray,
-            parentPaths: parentPathsArray,
-            debugName,
-        });
+        measureBlock(() => {
+            // Watch it locally as well, so when we get the value we know to trigger the client callback
+            pathWatcher.watchPath({
+                callback: getOwnNodeId(),
+                paths: pathsArray,
+                parentPaths: parentPathsArray,
+                debugName,
+                noInitialTrigger: watchSpec.noInitialTrigger,
+            });
+            remoteWatcher.watchLatest({
+                paths: pathsArray,
+                parentPaths: parentPathsArray,
+                debugName,
+            });
+        }, "ClientWatcher()|setWatches|watchCalls");
     }
 
     private lastVersions = registerResource("paths|lastVersion", new Map<number, number>());
@@ -764,7 +776,30 @@ export class ClientWatcher {
     }
 
     public pathHasAnyWatchers(path: string) {
-        return !!this.valueFunctionWatchers.get(path)?.size;
+        let parentPath = getParentPathStr(path);
+        return !!this.valueFunctionWatchers.get(path)?.size || !!this.parentValueFunctionWatchers.get(parentPath)?.size;
+    }
+    public getWatchersForPath(path: string) {
+        let matched = new Set<WatchSpec>();
+        let parentPath = getParentPathStr(path);
+        let watchers = this.valueFunctionWatchers.get(path);
+        if (watchers) {
+            for (let watcher of watchers.values()) {
+                matched.add(watcher);
+            }
+        }
+        let parentWatchers = this.parentValueFunctionWatchers.get(parentPath);
+        if (parentWatchers) {
+            for (let [_, watcherObj] of parentWatchers) {
+                for (let watcher of watcherObj.lookup.values()) {
+                    if (!matchesParentRangeFilter({ parentPath, fullPath: path, start: watcherObj.start, end: watcherObj.end })) {
+                        continue;
+                    }
+                    matched.add(watcher);
+                }
+            }
+        }
+        return matched;
     }
 }
 export const clientWatcher = new ClientWatcher();

package/src/2-proxy/PathValueProxyWatcher.ts

@@ -32,7 +32,7 @@ import { DEPTH_TO_DATA, MODULE_INDEX, getCurrentCall, getCurrentCallObj } from "
 import { inlineNestedCalls } from "../3-path-functions/syncSchema";
 import { interceptCallsBase, runCall } from "../3-path-functions/PathFunctionHelpers";
 import { deepCloneCborx } from "../misc/cloneHelpers";
-import { formatPercent } from "socket-function/src/formatting/format";
+import { formatPercent, formatTime } from "socket-function/src/formatting/format";
 import { addStatPeriodic, interceptCalls, onAllPredictionsFinished, onTimeProfile } from "../-0-hooks/hooks";
 import { onNextPaint } from "../functional/onNextPaint";
 
@@ -202,6 +202,12 @@ export interface WatcherOptions<Result> {
      *          what you want, it depends on the usecase.
      */
     runOncePerPaint?: string;
+
+    /** Logs time to go from unsynced to synced, and the paths that were unloaded.
+     *      - In order to tell what paths to pre-load, and how much time we are waiting to load data.
+     *      - Also to tell us how long and how many paths are loading on startup.
+    */
+    logSyncTimings?: boolean;
 }
 
 let harvestableReadyLoopCount = 0;
@@ -330,6 +336,15 @@ export type SyncWatcher = {
     hackHistory: { message: string; time: number }[];
 
     createTime: number;
+
+    logSyncTimings?: {
+        startTime: number;
+        unsyncedPaths: Set<string>;
+        unsyncedStages: {
+            paths: string[];
+            time: number;
+        }[];
+    };
 }
 function addToHistory(watcher: SyncWatcher, message: string) {
     watcher.hackHistory.push({ message, time: Date.now() });
@@ -360,7 +375,7 @@ export function atomicObjectRead<T>(obj: T): T {
     return (obj as any)[readNoProxy];
 }
 export const atomic = atomicObjectRead;
-(global as any).atomic = atomic;
+(globalThis as any).atomic = atomic;
 
 export function doUnatomicWrites<T>(callback: () => T): T {
     return doProxyOptions({ atomicWrites: false }, callback);
@@ -860,7 +875,6 @@ export class PathValueProxyWatcher {
             return getKeys(pathValue?.value) as string[];
         }
 
-        let keys: string[] = [];
         let childPaths = authorityStorage.getPathsFromParent(pathStr);
 
         // We need to also get keys from pendingWrites
@@ -877,23 +891,26 @@ export class PathValueProxyWatcher {
             }
         }
 
+        let keys = new Set<string>();
         if (childPaths) {
             let targetDepth = getPathDepth(pathStr);
             for (let childPath of childPaths) {
                 let key = getPathIndexAssert(childPath, targetDepth);
                 let childValue = this.getCallback(childPath, undefined, "readTransparent");
                 if (childValue?.value !== undefined) {
-                    keys.push(key);
+                    keys.add(key);
                 }
             }
         }
 
+        let keysArray = Array.from(keys);
+
         // NOTE: Because getPathsFromParent does not preserve order, we have to sort here to ensure
         //  we provide a consistent order (which might not be the order the user wants, but at least
         //  it will always fail if it does fail).
-        keys.sort();
+        keysArray.sort();
 
-        return keys;
+        return keysArray;
     };
 
     private getSymbol = (pathStr: string, symbol: symbol): { value: unknown } | undefined => {
@@ -1119,6 +1136,8 @@ export class PathValueProxyWatcher {
             for (let callback of disposeCallbacks) {
                 logErrors(((async () => { await callback(); }))());
             }
+
+            self.allWatchersLookup.delete(trigger);
         }
         function runWatcher() {
             watcher.pendingWrites.clear();
@@ -1253,8 +1272,56 @@ export class PathValueProxyWatcher {
             const specialPromiseUnsynced = watcher.specialPromiseUnsynced;
             watcher.specialPromiseUnsynced = false;
 
+            let anyUnsynced = watcher.hasAnyUnsyncedAccesses();
+            if (watcher.options.logSyncTimings) {
+                if (anyUnsynced) {
+                    watcher.logSyncTimings = watcher.logSyncTimings || {
+                        startTime: Date.now(),
+                        unsyncedPaths: new Set(),
+                        unsyncedStages: [],
+                    };
+                    let newPaths: string[] = [];
+                    let set = watcher.logSyncTimings.unsyncedPaths;
+                    function addPath(path: string) {
+                        if (set.has(path)) return;
+                        set.add(path);
+                        newPaths.push(path);
+                    }
+                    for (let path of watcher.lastUnsyncedAccesses) {
+                        addPath(path);
+                    }
+                    for (let path of watcher.lastUnsyncedParentAccesses) {
+                        addPath(path);
+                    }
+                    if (newPaths.length > 0) {
+                        watcher.logSyncTimings.unsyncedStages.push({
+                            paths: newPaths,
+                            time: Date.now(),
+                        });
+                    }
+                } else {
+                    if (watcher.logSyncTimings) {
+                        let now = Date.now();
+                        console.groupCollapsed(`${watcher.debugName} synced in ${formatTime(now - watcher.logSyncTimings.startTime)}`);
+                        // Log the stages
+                        let stages = watcher.logSyncTimings.unsyncedStages;
+                        for (let i = 0; i < stages.length; i++) {
+                            let nextTime = stages[i + 1]?.time || now;
+                            let stage = stages[i];
+                            console.groupCollapsed(`${formatTime(nextTime - stage.time)}`);
+                            for (let path of stage.paths) {
+                                console.log(path);
+                            }
+                            console.groupEnd();
+                        }
+                        console.groupEnd();
+                        watcher.logSyncTimings = undefined;
+                    }
+                }
+            }
+
             if (!watcher.options.static) {
-                if (!watcher.hasAnyUnsyncedAccesses()) {
+                if (!anyUnsynced) {
                     watcher.countSinceLastFullSync = 0;
                     watcher.lastSyncTime = Date.now();
                     watcher.syncRunCount++;
@@ -1701,6 +1768,8 @@ export class PathValueProxyWatcher {
         trigger = measureWrap(trigger, `(watcher) ${watcher.debugName}`);
         watcher.explicitlyTrigger = trigger;
 
+        self.allWatchersLookup.set(trigger, watcher);
+
         if (options.static) {
             // Do nothing, this will be explicitly triggered when needed
         } else if (options.runImmediately) {
@@ -1880,6 +1949,10 @@ export class PathValueProxyWatcher {
 
 
     private allWatchers = registerResource("paths|proxyWatcher.allWatchers", new Set<SyncWatcher>());
+    private allWatchersLookup = registerResource("paths|proxyWatcher.allWatchersLookup", new Map<Function, SyncWatcher>());
+    public getWatcherForTrigger(trigger: Function): SyncWatcher | undefined {
+        return this.allWatchersLookup.get(trigger);
+    }
     public getAllWatchers(): Set<SyncWatcher> {
         return this.allWatchers;
     }
@@ -2025,6 +2098,10 @@ export class PathValueProxyWatcher {
         }
         return getPathFromProxy(proxy);
     }
+
+    public ignoreWatches<T>(code: () => T) {
+        return doProxyOptions({ noSyncing: true }, code);
+    }
 }
 
 const PAINT_NOOP_FUNCTION = () => { };
@@ -2146,13 +2223,13 @@ export function noAtomicSchema<T>(code: () => T) {
 
 
 export const proxyWatcher = new PathValueProxyWatcher();
-(global as any).proxyWatcher = proxyWatcher;
-(global as any).ProxyWatcher = PathValueProxyWatcher;
+(globalThis as any).proxyWatcher = proxyWatcher;
+(globalThis as any).ProxyWatcher = PathValueProxyWatcher;
 // Probably the most useful debug function for debugging watch based functions.
-(global as any).getCurrentTriggers = function () {
+(globalThis as any).getCurrentTriggers = function () {
     return proxyWatcher.getTriggeredWatcher().triggeredByChanges;
 };
-(global as any).getAllWatchers = function () {
+(globalThis as any).getAllWatchers = function () {
     return proxyWatcher.getAllWatchers();
 };
 

package/src/4-dom/qreact.tsx

@@ -134,6 +134,9 @@ export interface QComponentStatic {
      *           UNLESS the child explicitly sets this to false.
      * */
     multiRendersPerPaint?: boolean;
+
+    /** If true, logs time it takes for component to load synced data (if at all), and the paths that were unloaded. */
+    logLoadTime?: boolean;
 }
 
 /** See QComponentStatic.jsonComparePropUpdates */
@@ -172,6 +175,8 @@ export class qreact {
 
     public static errorHandler: ErrorHandler;
 
+    public static domUpdateCount = 0;
+
     public static debug = async () => {
         const { enableDebugComponents } = await import("../5-diagnostics/qreactDebug");
         enableDebugComponents();
@@ -414,7 +419,14 @@ function getAncestor(
 }
 function onDispose(fnc: () => void) {
     let component = getRenderingComponent();
-    if (!component) throw new Error(`Can only call onDispose if inside of a render (or componentDidMount) function. If an an event callback, call qreact.getRenderingComponent in render, and then call qreact.watchDispose(component, callback).`);
+    if (!component) {
+        if (QRenderClass.renderingComponentId !== undefined) {
+            // If it's already disposed... call the function immediately?
+            fnc();
+            return;
+        }
+        throw new Error(`Can only call onDispose if inside of a render (or componentDidMount) function. If an an event callback, call qreact.getRenderingComponent in render, and then call qreact.watchDispose(component, callback).`);
+    }
     watchDispose(component, fnc);
 }
 function watchDispose(renderClass: ExternalRenderClass, fnc: () => void) {
@@ -490,6 +502,23 @@ class QRenderClass {
 
         let vNode = config.vNode;
         let self = this;
+
+        const contextCommit = (callback: () => void) => {
+            void Promise.resolve().finally(() => {
+                logErrors(proxyWatcher.commitFunction({
+                    canWrite: true,
+                    watchFunction() {
+                        QRenderClass.renderingComponentId = self.id;
+                        try {
+                            callback();
+                        } finally {
+                            QRenderClass.renderingComponentId = undefined;
+                        }
+                    },
+                }));
+            });
+        };
+
         // Set up watchers for virtual watching AND dom mounting
         let debugName = vNode.type.name + `|${this.id}|`;
         const getDebugName = (type: string) => {
@@ -564,7 +593,9 @@ class QRenderClass {
         self.instance.componentWillMount && logErrors(proxyWatcher.commitFunction({
             debugName: getDebugName("componentWillMount"),
             watchFunction() {
-                self.instance.componentWillMount?.();
+                contextCommit(() => {
+                    self.instance.componentWillMount?.();
+                });
             },
         }));
 
@@ -595,6 +626,7 @@ class QRenderClass {
         const renderWatcher = this.renderWatcher = proxyWatcher.createWatcher({
             debugName: getDebugName("render"),
             canWrite: true,
+            logSyncTimings: statics.logLoadTime,
             runOncePerPaint: !multiRendersPerPaint && `${this.debugName}|${self.id}` || undefined,
             watchFunction() {
 
@@ -702,7 +734,9 @@ class QRenderClass {
                 //  ALSO, this stops infinite loops caused by self triggering, which is really useful.
                 if (!QRenderClass.areVNodesEqual(comparePrevVNode, vNode)) {
                     self.data().vNodeForRender = frozen;
-                    comparePrevVNode = frozen.value;
+                    if (Querysub.isAllSynced()) {
+                        comparePrevVNode = frozen.value;
+                    }
                 } else {
                     wastedRenders++;
                     QRenderClass.areVNodesEqual(comparePrevVNode, vNode);
@@ -836,6 +870,10 @@ class QRenderClass {
                         if ("data-break" in nextProps) {
                             debugger;
                         }
+                        todonext;
+                        // First of all, we are accessing deepProps on the WRONG value. We should be accessing it on the child statics, not our statics!
+                        // Second of all... we need to check if our child is JSON comparing, and if so, do an atomic write of the props. Usually we don't want to do an atomic write, as this would force an update every render, but... if it is JSON comparing, it won't force an update.
+                        //  - Which is actually trivial. We just literally set .props = nextProps. Done.
                         if (statics.deepProps) {
                             // NOTE: By removing atomic we can leverage the proxy automatically decomposing
                             //  the props to each individual primitive value, and checking each individual
@@ -1111,22 +1149,6 @@ class QRenderClass {
                     }
                 }
 
-                const contextCommit = (callback: () => void) => {
-                    void Promise.resolve().finally(() => {
-                        logErrors(proxyWatcher.commitFunction({
-                            canWrite: true,
-                            watchFunction() {
-                                QRenderClass.renderingComponentId = self.id;
-                                try {
-                                    callback();
-                                } finally {
-                                    QRenderClass.renderingComponentId = undefined;
-                                }
-                            },
-                        }));
-                    });
-                };
-
                 // NOTE: This is a bit inefficient as it requires running twice, because the first run our child
                 //  components will have no rootDOMNodes. But... it's probably fine...
                 QRenderClass.diffVNodes({
@@ -1946,14 +1968,17 @@ function updateDOMNodeFields(domNode: DOMNode, vNode: VirtualDOM, prevVNode: Vir
                         if (typeof v === "number" && !IS_NON_DIMENSIONAL.test(key)) {
                             v = v + "px";
                         }
-                        (domNode as any).style[key] = v ?? "";
+                        if (String(v).endsWith("!important")) {
+                            (domNode as any).style.setProperty(key, String(v).slice(0, -"!important".length), "important");
+                        } else {
+                            (domNode as any).style[key] = v ?? "";
+                        }
                     }
                     if (canHaveChildren(prevValue)) {
                         for (let key in prevValue) {
                             if (!(key in value)) {
                                 (domNode as any).style[key] = "";
                             }
-
                         }
                     }
                 }
@@ -2675,6 +2700,7 @@ let baseTrigger = lazy(async () => {
     }
 });
 function triggerGlobalOnMountWatch(component: QRenderClass) {
+    qreact.domUpdateCount++;
     pendingGlobalOnMountWatches.push(component);
     void baseTrigger();
 }

package/src/4-querysub/Querysub.ts

@@ -38,13 +38,13 @@ import { sha256 } from "js-sha256";
 import { minify_sync } from "terser";
 import { isClient } from "../config2";
 import { waitForFirstTimeSync } from "socket-function/time/trueTimeShim";
-import { logMeasureTable, measureBlock, measureFnc, startMeasure } from "socket-function/src/profiling/measure";
+import { logMeasureTable, measureBlock, measureFnc, measureWrap, startMeasure } from "socket-function/src/profiling/measure";
 import { delay } from "socket-function/src/batching";
 import { MaybePromise } from "socket-function/src/types";
 import { devDebugbreak, getDomain, isDynamicallyLoading, isPublic, noSyncing } from "../config";
 import { Schema2, Schema2T, t } from "../2-proxy/schema2";
 import { CALL_PERMISSIONS_KEY } from "./permissionsShared";
-import yargs from "yargs";
+import yargs, { check } from "yargs";
 import { parseArgsFactory } from "../misc/rawParams";
 
 import * as typesafecss from "typesafecss";
@@ -211,6 +211,8 @@ export class Querysub {
     public static callRandom = () => hashRandom(Querysub.getCallId(), getNextCallIndex());
     public static nextId = () => Querysub.getCallId() + "_" + getNextCallIndex();
 
+    public static getNextCallIndex = getNextCallIndex;
+
     public static configRootDiscoveryLocation = configRootDiscoveryLocation;
 
 
@@ -280,13 +282,14 @@ export class Querysub {
         await nodePathAuthority.waitUntilRoutingIsReady();
     }
 
-    public static createWatcher(watcher: (obj: SyncWatcher) => void): {
+    public static createWatcher(watcher: (obj: SyncWatcher) => void, options?: Partial<WatcherOptions<unknown>>): {
         dispose: () => void;
         explicitlyTrigger: () => void;
     } {
         return proxyWatcher.createWatcher({
             debugName: watcher.name,
             canWrite: true,
+            ...options,
             watchFunction: () => {
                 return watcher(proxyWatcher.getTriggeredWatcher());
             },
@@ -358,6 +361,9 @@ export class Querysub {
             allowProxyResults: true,
         });
     }
+    public static fastReadAsync<T>(fnc: () => T, options?: Partial<WatcherOptions<T>>) {
+        return Querysub.serviceWrite(fnc, { ...options, allowProxyResults: true });
+    }
     public static localRead<T>(fnc: () => T, options?: Partial<WatcherOptions<T>>) {
         return proxyWatcher.runOnce({
             watchFunction: fnc,
@@ -417,6 +423,18 @@ export class Querysub {
             Querysub.commit(callback);
         });
     }
+    public static onSynced(callback: () => void) {
+        let watcher = proxyWatcher.getTriggeredWatcherMaybeUndefined();
+        Querysub.onCommitFinished(() => {
+            if (!watcher || !watcher.hasAnyUnsyncedAccesses()) {
+                callback();
+            }
+        });
+    }
+    /** Checks all recursive watches. However... if something writes to a value you watch (ex, DerivedCache), we can't track that, so this is of limited use. */
+    public static onNestedSynced(callback: () => void) {
+        onNestedSynced(callback);
+    }
 
     /** A more powerful version of omCommitFinished, which even waits for call predictions (or tries to).
      *      - Also see afterPredictionsSynced, which runs the callback in a write.
@@ -432,7 +450,7 @@ export class Querysub {
      *      you can't call this at the start of your function (as nothing will have been called yet).
      *  NOTE: This can also be used to prevent
      */
-    public static afterPredictions(callback: () => Promise<void>) {
+    public static afterPredictions(callback: () => MaybePromise<void>) {
         let calls = proxyWatcher.getTriggeredWatcher().pendingCalls.map(x => x.call);
         Querysub.onCommitFinished(async () => {
             await Promise.all(calls.map(x => Querysub.onCallPredict(x)));
@@ -496,6 +514,10 @@ export class Querysub {
         return isSynced(value);
     }
 
+    public static ignoreWatches<T>(code: () => T) {
+        return proxyWatcher.ignoreWatches(code);
+    }
+
     public static assertDomainAllowed(path: string) {
         let domain = getPathIndexAssert(path, 0);
         if (!Querysub.trustedDomains.has(domain)) {
@@ -1021,6 +1043,7 @@ function getNextCallIndex() {
     if (triggeredWatcher !== triggered) {
         triggered.onAfterTriggered.push(() => {
             nextCallIndex = 1;
+            triggeredWatcher = undefined;
         });
         triggeredWatcher = triggered;
     }
@@ -1058,26 +1081,40 @@ let initInterval = cache((interval: number) => {
     }, interval);
 });
 
+function getSetTime() {
+    let call = getCurrentCallAllowUndefined();
+    if (call) {
+        return call.runAtTime.time;
+    }
+    let watcher = proxyWatcher.getTriggeredWatcherMaybeUndefined();
+    if (watcher?.options.temporary) {
+        return watcher.createTime;
+    }
+    return undefined;
+}
+
 let lastTime = 0;
 function getSyncedTimeUnique() {
+    let setTime = getSetTime();
+    if (setTime !== undefined) {
+        return addEpsilons(setTime, getNextCallIndex());
+    }
+
     let time = getSyncedTime();
     if (time <= lastTime) {
-        time = addEpsilons(time, 1);
+        time = addEpsilons(lastTime, 1);
     }
     lastTime = time;
     return time;
 }
 
 function getSyncedTime() {
-    let call = getCurrentCallAllowUndefined();
-    if (call) {
-        return call.runAtTime.time;
-    }
-    let watcher = proxyWatcher.getTriggeredWatcherMaybeUndefined();
-    if (watcher?.options.temporary) {
-        return watcher.createTime;
+    let setTime = getSetTime();
+    if (setTime !== undefined) {
+        return setTime;
     }
     if (isNode()) {
+        let watcher = proxyWatcher.getTriggeredWatcherMaybeUndefined();
         if (watcher) {
             throw new Error(`Trying to access time in a serverside non-temporary watcher. Clientside this is allowed, as infinite loops (render every frame) makes sense. Serverside this is not allowed. Did you try to run a call-type operatin in a watcher? If you manually created a watcher, you might want to set "temporary: true" if you will be immediately disposing it. You almost might want to fork your write logic with setImmediate to detach this from your watcher, so your write can access a single non-changing time. In ${watcher.debugName}`);
         }
@@ -1098,6 +1135,72 @@ function timeDelayed(interval: number) {
     return Date.now();
 }
 
+let nestedSyncDedupeHack = new Map<string, () => void>();
+
+const onNestedSynced = measureWrap(function onNestedSynced(callback: () => void) {
+    const watcher = proxyWatcher.getTriggeredWatcherMaybeUndefined();
+    if (!watcher) {
+        callback();
+        return;
+    }
+
+    let key = watcher.debugName + "_" + callback.toString();
+    if (nestedSyncDedupeHack.has(key)) {
+        nestedSyncDedupeHack.set(key, callback);
+        return;
+    }
+    nestedSyncDedupeHack.set(key, callback);
+
+    const getPendingWatcher = (): SyncWatcher | undefined => {
+        let checkWatchers: SyncWatcher[] = [];
+        let checkedWatchers = new Set<SyncWatcher>();
+        checkWatchers.push(watcher);
+        while (true) {
+            let watcher = checkWatchers.shift();
+            if (!watcher) break;
+            if (watcher.hasAnyUnsyncedAccesses()) return watcher;
+            // Wait until it's had time to spawn children watchers
+            if (watcher.syncRunCount === 0) return watcher;
+            let writes = watcher.pendingWrites;
+            for (let writePath of writes.keys()) {
+                // Find any watchers of these writes
+                let callbacks = clientWatcher.getWatchersForPath(writePath);
+                for (let callback of callbacks) {
+                    let nestedWatcher = proxyWatcher.getWatcherForTrigger(callback.callback);
+                    if (!nestedWatcher) continue;
+                    if (checkedWatchers.has(nestedWatcher)) continue;
+                    checkedWatchers.add(nestedWatcher);
+                    checkWatchers.push(nestedWatcher);
+                }
+            }
+        }
+
+        return undefined;
+    };
+    const checkAgain = () => {
+        const pendingWatcher = getPendingWatcher();
+        if (!pendingWatcher) {
+            callback();
+            nestedSyncDedupeHack.delete(key);
+        } else {
+            //console.log(`Waiting for ${pendingWatcher.debugName} to finish`);
+            getPendingWatcher();
+            let waitPromise = clientWatcher.waitForTriggerFinished();
+            if (!waitPromise) {
+                pendingWatcher.onAfterTriggered.push(checkAgain);
+            } else {
+                void waitPromise.finally(() => {
+                    checkAgain();
+                });
+            }
+        }
+    };
+    Querysub.onCommitFinished(() => {
+        checkAgain();
+    });
+});
+
+
 // Returns a value between 0 and 1
 function hashRandom(base: string, offset: number): number {
     let hashBuf = Buffer.from(sha256(base + "_" + offset), "hex");
@@ -1160,4 +1263,5 @@ import { formatNumber, formatTime } from "socket-function/src/formatting/format"
 import { css } from "../4-dom/css";
 import { getCountPerPaint } from "../functional/onNextPaint";
 import { addEpsilons } from "../bits";
+import { blue } from "socket-function/src/formatting/logColors";
 

package/src/5-diagnostics/FullscreenModal.tsx

@@ -1,17 +1,56 @@
 import preact from "preact";
 import { qreact } from "../4-dom/qreact";
 import { Button } from "../library-components/Button";
-import { Modal } from "./Modal";
+import { Modal, showModal } from "./Modal";
 
 
-export class FullscreenModal extends preact.Component<{
+export class FullscreenModal extends qreact.Component<{
     parentState?: { open: boolean };
     onCancel?: () => void | "abortClose";
     style?: preact.JSX.CSSProperties;
     outerStyle?: preact.JSX.CSSProperties;
     onlyExplicitClose?: boolean;
+    noModalWrap?: boolean;
 }> {
     render() {
+        let base = <div
+            className="FullscreenModal"
+            style={{
+                position: "fixed",
+                top: 0,
+                left: 0,
+                width: "100vw",
+                height: "100vh",
+                background: "hsla(0, 0%, 30%, 0.5)",
+                padding: 100,
+                display: "flex",
+                alignItems: "center",
+                justifyContent: "center",
+                overflow: "auto",
+                cursor: "pointer",
+                ...this.props.outerStyle,
+            }}
+        >
+            <div
+                className="FullscreenModal-background keepModalsOpen"
+                style={{
+                    background: "hsl(0, 0%, 100%)",
+                    padding: 20,
+                    color: "hsl(0, 0%, 7%)",
+                    cursor: "default",
+                    width: "100%",
+                    display: "flex",
+                    flexDirection: "column",
+                    gap: 10,
+                    maxHeight: "calc(100% - 200px)",
+                    overflow: "auto",
+                    ...this.props.style
+                }}
+            >
+                {this.props.children}
+            </div>
+        </div>;
+        if (this.props.noModalWrap) return base;
         return (
             <Modal
                 onClose={() => {
@@ -19,43 +58,21 @@ export class FullscreenModal extends preact.Component<{
                     return this.props.onCancel?.();
                 }}
             >
-                <div
-                    style={{
-                        position: "fixed",
-                        top: 0,
-                        left: 0,
-                        width: "100vw",
-                        height: "100vh",
-                        background: "hsla(0, 0%, 30%, 0.5)",
-                        padding: 100,
-                        display: "flex",
-                        alignItems: "center",
-                        justifyContent: "center",
-                        overflow: "auto",
-                        cursor: "pointer",
-                        ...this.props.outerStyle,
-                    }}
-                >
-                    <div
-                        className="keepModalsOpen"
-                        style={{
-                            background: "hsl(0, 0%, 100%)",
-                            padding: 20,
-                            color: "hsl(0, 0%, 7%)",
-                            cursor: "default",
-                            width: "100%",
-                            display: "flex",
-                            flexDirection: "column",
-                            gap: 10,
-                            maxHeight: "calc(100% - 200px)",
-                            overflow: "auto",
-                            ...this.props.style
-                        }}
-                    >
-                        {this.props.children}
-                    </div>
-                </div>
+                {base}
             </Modal>
         );
     }
-}
+}
+
+export function showFullscreenModal(config: {
+    content: preact.ComponentChild;
+    onClose?: () => void | "abortClose";
+}): {
+    close: () => void;
+} {
+    let { close } = showModal({
+        content: <FullscreenModal noModalWrap>{config.content}</FullscreenModal>,
+        onClose: config.onClose,
+    });
+    return { close };
+}

package/src/5-diagnostics/Modal.tsx

@@ -1,10 +1,10 @@
-import preact from "preact";
 import { nextId } from "socket-function/src/misc";
 import { lazy } from "socket-function/src/caching";
 import { css } from "typesafecss";
 import { Querysub } from "../4-querysub/Querysub";
 import { atomicObjectWrite, atomicObjectWriteNoFreeze } from "../2-proxy/PathValueProxyWatcher";
 import { qreact } from "../4-dom/qreact";
+import { FullscreenModal } from "./FullscreenModal";
 
 const data = Querysub.createLocalSchema<{
     modals: {
@@ -41,14 +41,16 @@ const ensureRendering = lazy(() => {
 });
 
 /** IMPORTANT! Use the .keepModalsOpen class to prevent clicks from closing the model */
-export class Modal extends preact.Component<{
+export class Modal extends qreact.Component<{
     onClose?: () => void | "abortClose";
 }> {
     id = nextId();
     componentWillUnmount(): void {
+        console.log("Unmounting modal", this.id);
         delete data().modals[this.id];
     }
     render() {
+        console.log("Rendering modal", this.id);
         ensureRendering();
         data().modals[this.id] = atomicObjectWriteNoFreeze({
             value: this.props.children,
@@ -65,6 +67,7 @@ function closeModal(id: string) {
     if (result === "abortClose") return;
     delete data().modals[id];
 }
+
 export function showModal(config: {
     content: preact.ComponentChild;
     onClose?: () => void | "abortClose";
@@ -94,7 +97,7 @@ export function closeAllModals() {
 }
 
 
-export class ModalHolder extends preact.Component {
+export class ModalHolder extends qreact.Component {
     render() {
         let modals = Object.values(data().modals);
         return (

package/src/5-diagnostics/qreactDebug.tsx

@@ -186,10 +186,15 @@ class WatchModal extends qreact.Component<{
                     || {}
                 }
                 style={
-                    pos === "fill" && {}
-                    || pos === "top" && { maxHeight: "100%" }
-                    || pos === "bottom" && { maxHeight: "100%" }
-                    || {}
+                    {
+                        ...(
+                            pos === "fill" && {}
+                            || pos === "top" && { maxHeight: "100%" }
+                            || pos === "bottom" && { maxHeight: "100%" }
+                            || {}
+                        ),
+                        background: "rgb(255, 255, 255)!important",
+                    }
                 }
                 onCancel={() => {
                     if (this.state.pos !== "fill") {
@@ -197,7 +202,7 @@ class WatchModal extends qreact.Component<{
                     }
                 }}
             >
-                <div class={css.hsl(0, 0, 100).vbox(6)}>
+                <div class={css.hsl(0, 0, 100).hslcolor(0, 0, 10).vbox(6)}>
                     <div class={css.hbox(10).fillWidth}>
                         {component.debugName}
                         {parent && <Button onClick={() => this.state.parentNavigate++}>

package/src/diagnostics/misc-pages/ArchiveViewerTree.tsx

@@ -53,7 +53,10 @@ export class ArchiveViewerTree extends qreact.Component<{
         let { remainingWidth, nodePath, scaleType } = config;
         const selectedPath = archiveTreeSelected.value;
 
-        const sumFormatter = this.props.sumFormatter || formatNumber;
+        let sumFormatter: (value: number) => string = formatNumber;
+        if (archiveTreeScale.value === "size") {
+            sumFormatter = this.props.sumFormatter || formatNumber;
+        }
 
         let isSelected = selectedPath === nodePath;
         let isDescendantSelected = selectedPath.startsWith(nodePath);

package/src/errors.ts

@@ -112,6 +112,7 @@ export function errorify(error: any, messageOverride?: string) {
         errorObj.stack = error;
     } else {
         errorObj.message = error;
+        errorObj.stack = error + "\n" + errorObj.stack;
     }
     if (messageOverride) {
         errorObj.message = messageOverride;

package/src/library-components/ATag.tsx

@@ -28,6 +28,8 @@ export type ATagProps = (
          */
         rawLink?: boolean;
         lightMode?: boolean;
+        noStyles?: boolean;
+        onRef?: (element: HTMLAnchorElement | null) => void;
     }
 );
 
@@ -50,6 +52,7 @@ export class ATag extends qreact.Component<ATagProps> {
             <a
                 tabIndex={0}
                 {...props}
+                ref={props.onRef}
                 className={
                     (isCurrent ? css.color(`hsl(110, 75%, ${lightness}%)`) : css.color(`hsl(210, 100%, ${lightness}%)`))
                     + css.textDecoration("none")
@@ -57,6 +60,12 @@ export class ATag extends qreact.Component<ATagProps> {
                         .outline("3px solid hsl(204, 100%, 50%)", "focus")
                     + (props.className ?? props.class)
 
+                    + (props.noStyles && css
+                        .textDecoration("none", "important")
+                        .outline("none", "important")
+                        .color("inherit", "important")
+                    )
+
                 }
                 onClick={e => {
                     if (this.props.rawLink) return;

package/src/library-components/icons.tsx

@@ -688,5 +688,13 @@ export const Icon = {
             <path d="M15 15V14H14V15H15ZM20.2929 21.7071C20.6834 22.0976 21.3166 22.0976 21.7071 21.7071C22.0976 21.3166 22.0976 20.6834 21.7071 20.2929L20.2929 21.7071ZM15 9H14V10H15V9ZM21.7071 3.70711C22.0976 3.31658 22.0976 2.68342 21.7071 2.29289C21.3166 1.90237 20.6834 1.90237 20.2929 2.29289L21.7071 3.70711ZM9 15H10V14H9V15ZM2.29289 20.2929C1.90237 20.6834 1.90237 21.3166 2.29289 21.7071C2.68342 22.0976 3.31658 22.0976 3.70711 21.7071L2.29289 20.2929ZM9 9V10H10V9H9ZM3.70711 2.29289C3.31658 1.90237 2.68342 1.90237 2.29289 2.29289C1.90237 2.68342 1.90237 3.31658 2.29289 3.70711L3.70711 2.29289ZM16 20V15H14V20H16ZM15 16H20V14H15V16ZM14.2929 15.7071L20.2929 21.7071L21.7071 20.2929L15.7071 14.2929L14.2929 15.7071ZM14 4V9H16V4H14ZM15 10H20V8H15V10ZM15.7071 9.70711L21.7071 3.70711L20.2929 2.29289L14.2929 8.29289L15.7071 9.70711ZM10 20V15H8V20H10ZM9 14H4V16H9V14ZM8.29289 14.2929L2.29289 20.2929L3.70711 21.7071L9.70711 15.7071L8.29289 14.2929ZM8 4V9H10V4H8ZM9 8H4V10H9V8ZM9.70711 8.29289L3.70711 2.29289L2.29289 3.70711L8.29289 9.70711L9.70711 8.29289Z" fill="#33363F" />
         </svg>
 
+    ),
+    // TODO: Create a better warning (something that looks good at low sizes)
+    warning: fastSVG(
+        <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 122.88 111.54" width="24" height="24">
+            <path fill="#cf1f25" d="M2.35,84.42,45.28,10.2l.17-.27h0A23,23,0,0,1,52.5,2.69,17,17,0,0,1,61.57,0a16.7,16.7,0,0,1,9.11,2.69,22.79,22.79,0,0,1,7,7.26q.19.32.36.63l42.23,73.34.24.44h0a22.48,22.48,0,0,1,2.37,10.19,17.63,17.63,0,0,1-2.17,8.35,15.94,15.94,0,0,1-6.93,6.6c-.19.1-.39.18-.58.26a21.19,21.19,0,0,1-9.11,1.75v0H17.61c-.22,0-.44,0-.65,0a18.07,18.07,0,0,1-6.2-1.15A16.42,16.42,0,0,1,3,104.24a17.53,17.53,0,0,1-3-9.57,23,23,0,0,1,1.57-8.74,7.66,7.66,0,0,1,.77-1.51Z" />
+            <path fill="#fec901" fill-rule="evenodd" d="M9,88.75,52.12,14.16c5.24-8.25,13.54-8.46,18.87,0l42.43,73.69c3.39,6.81,1.71,16-9.33,15.77H17.61C10.35,103.8,5.67,97.43,9,88.75Z" />
+            <path fill="#010101" d="M57.57,83.78A5.53,5.53,0,0,1,61,82.2a5.6,5.6,0,0,1,2.4.36,5.7,5.7,0,0,1,2,1.3,5.56,5.56,0,0,1,1.54,5,6.23,6.23,0,0,1-.42,1.35,5.57,5.57,0,0,1-5.22,3.26,5.72,5.72,0,0,1-2.27-.53A5.51,5.51,0,0,1,56.28,90a5.18,5.18,0,0,1-.36-1.27,5.83,5.83,0,0,1-.06-1.31h0a6.53,6.53,0,0,1,.57-2,4.7,4.7,0,0,1,1.14-1.56Zm8.15-10.24c-.19,4.79-8.31,4.8-8.49,0-.82-8.21-2.92-29.34-2.86-37.05.07-2.38,2-3.79,4.56-4.33a12.83,12.83,0,0,1,5,0c2.61.56,4.65,2,4.65,4.44v.24L65.72,73.54Z" />
+        </svg>
     )
 };

package/src/misc/format2.ts

@@ -1,8 +1,24 @@
+function canBeJSON(str: string) {
+    return (
+        str === "null"
+        || str === "true"
+        || str === "false"
+        || str[0] === `"` && str[str.length - 1] === `"`
+        || str[0] === `[` && str[str.length - 1] === `]`
+        || str[0] === `{` && str[str.length - 1] === `}`
+        || (48 <= str.charCodeAt(0) && str.charCodeAt(0) <= 57)
+        || str.length > 1 && str[0] === "-" && (48 <= str.charCodeAt(1) && str.charCodeAt(1) <= 57)
+    );
+}
+
 export function parseNice(text: string): unknown {
     if (text === "undefined") return undefined;
-    try {
-        return JSON.parse(text);
-    } catch { }
+    if (text === undefined) return undefined;
+    if (canBeJSON(text)) {
+        try {
+            return JSON.parse(text);
+        } catch { }
+    }
     return text;
 }
 export function stringifyNice(value: unknown): string {

package/src/user-implementation/UserPage.tsx

@@ -251,16 +251,18 @@ export class UserPage extends qreact.Component {
                         <table>
                             <tr>
                                 <th>User ID</th>
+                                <th>Email</th>
                                 <th>Time</th>
                             </tr>
-                            {sort(Object.entries(userObj.invitedUsers), x => -x[1].time).map(([userId, inviteData]) => {
+                            {sort(Object.entries(userObj.invitedUsers2), x => -x[1].time).map(([email, inviteData]) => {
                                 return (
                                     <tr>
                                         <td>
-                                            <Anchor values={[{ param: viewingUserURL, value: userId }]}>
-                                                {userId}
+                                            <Anchor values={[{ param: viewingUserURL, value: inviteData.userId }]}>
+                                                {inviteData.userId}
                                             </Anchor>
                                         </td>
+                                        <td>{inviteData.email}</td>
                                         <td>{inviteData.time}</td>
                                     </tr>
                                 );

package/src/user-implementation/userData.ts

@@ -133,8 +133,10 @@ export type User = {
     };
 
     invitesRemaining: number;
-    invitedUsers: {
-        [userId: string]: {
+    invitedUsers2: {
+        [email: string]: {
+            userId: string;
+            email: string;
             time: number;
         };
     };
@@ -427,7 +429,7 @@ function getLoadingUserObj() {
         email: "",
         settings: { displayName: "" }, userType: "anonymous" as const,
         createTime: 0,
-        machineIds: {}, allowedIPs: {}, loginTokens: {}, lastPageLoadsIPs: {}, invitedUsers: {},
+        machineIds: {}, allowedIPs: {}, loginTokens: {}, lastPageLoadsIPs: {}, invitedUsers2: {},
         invitesRemaining: 0
     };
 }
@@ -452,7 +454,7 @@ export function getCurrentUserObj(): User | undefined {
             allowedIPs: {},
             loginTokens: {},
             lastPageLoadsIPs: {},
-            invitedUsers: {},
+            invitedUsers2: {},
             invitesRemaining: 0,
         };
     }
@@ -537,9 +539,10 @@ function internalCreateUser(config: {
             allowedIPs: {},
             loginTokens: {},
             lastPageLoadsIPs: {},
-            invitedUsers: {},
+            invitedUsers2: {},
             invitesRemaining: 0,
         };
+        data().secure.emailToUserId[email] = userId;
     }
     return data().users[userId];
 }
@@ -776,7 +779,7 @@ function registerPageLoadTime() {
 function inviteUser(config: { email: string }) {
     Querysub.ignorePermissionsChecks(() => {
         let curUserObj = getUserObjAssert();
-        if (config.email in curUserObj.invitedUsers) {
+        if (config.email in curUserObj.invitedUsers2) {
             console.info(`User ${config.email} already invited`);
             return;
         }
@@ -793,7 +796,9 @@ function inviteUser(config: { email: string }) {
             throw new Error("No invites remaining");
         }
 
-        curUserObj.invitedUsers[config.email] = atomicObjectWrite({
+        curUserObj.invitedUsers2[email] = atomicObjectWrite({
+            userId,
+            email,
             time: Querysub.getCallTime(),
         });
         curUserObj.invitesRemaining--;
@@ -923,7 +928,7 @@ export function scriptCreateUser(config: {
         allowedIPs: {},
         loginTokens: {},
         lastPageLoadsIPs: {},
-        invitedUsers: {},
+        invitedUsers2: {},
         invitesRemaining: 0,
     };
     data().secure.emailToUserId[email] = userId;
@@ -980,7 +985,7 @@ export async function registerServicePermissions() {
                 allowedIPs: {},
                 loginTokens: {},
                 lastPageLoadsIPs: {},
-                invitedUsers: {},
+                invitedUsers2: {},
                 invitesRemaining: 0,
             };
         }