querysub 0.45.0 → 0.50.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.45.0",
+  "version": "0.50.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
@@ -24,7 +24,7 @@
     "node-forge": "https://github.com/sliftist/forge#e618181b469b07bdc70b968b0391beb8ef5fecd6",
     "pako": "^2.1.0",
     "preact": "^10.11.3",
-    "socket-function": "^0.41.0",
+    "socket-function": "^0.47.0",
     "terser": "^5.31.0",
     "typesafecss": "^0.6.3",
     "yaml": "^2.5.0",

package/src/-0-hooks/hooks.ts

@@ -0,0 +1,83 @@
+// Hooks, to allow function implementations to be declared after their first call
+//  (so static calls work).
+
+function createHookFunction<Fnc extends (...args: any[]) => void>(debugName: string): {
+    (...args: Parameters<Fnc>): void;
+    declare: (fnc: Fnc) => void;
+} {
+    let queuedCalls = [] as Parameters<Fnc>[];
+    let declaration: Fnc | undefined;
+    setImmediate(() => {
+        if (!declaration) {
+            throw new Error(`Hook function ${debugName} not declared`);
+        }
+        for (let call of queuedCalls) {
+            declaration(...call);
+        }
+    });
+    function fnc(...args: Parameters<Fnc>): void {
+        queuedCalls.push(args);
+    };
+    fnc.declare = (fnc: Fnc) => {
+        declaration = fnc;
+    };
+    return fnc;
+}
+
+export const addStatPeriodic = createHookFunction<
+    (
+        config: {
+            title: string,
+            getValue: () => number,
+            format?: (value: number) => string,
+        }
+    ) => void
+>("addStatPeriodic");
+
+
+export const addStatSumPeriodic = createHookFunction<
+    (
+        config: {
+            title: string,
+            getValue: () => number,
+            format?: (value: number) => string,
+        }
+    ) => void
+>("addStatSumPeriodic");
+
+export const addTimeProfileDistribution = createHookFunction<
+    (
+        title: string,
+        harvestTimeRanges: () => { start: number; end: number; }[],
+    ) => void
+>("addTimeProfileDistribution");
+
+export const onTimeProfile = createHookFunction<
+    (
+        title: string,
+        startTime: number,
+    ) => void
+>("onTimeProfile");
+
+import type { ExtraMetadata } from "../5-diagnostics/nodeMetadata";
+export const registerNodeMetadata = createHookFunction<
+    (
+        metadata: ExtraMetadata
+    ) => void
+>("registerNodeMetadata");
+
+export const logNodeStats = createHookFunction<
+    (
+        title: string,
+        format: (value: number) => string,
+        value: number,
+    ) => void
+>("logNodeStats");
+
+export const logNodeStateStats = createHookFunction<
+    (
+        title: string,
+        format: (value: number) => string,
+        value: number,
+    ) => void
+>("logNodeStateStats");

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

@@ -10,7 +10,7 @@ import { devDebugbreak } from "../config";
 import { formatNumber, formatTime } from "socket-function/src/formatting/format";
 import { blue, green } from "socket-function/src/formatting/logColors";
 import debugbreak from "debugbreak";
-import { addTimeProfileDistribution, onTimeProfile } from "../5-diagnostics/nodeMetadata";
+import { onTimeProfile } from "../-0-hooks/hooks";
 
 export function hasBackblazePermissions() {
     return isNode() && fs.existsSync(getBackblazePath());

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

@@ -26,6 +26,11 @@ import { diskLog } from "../diagnostics/logs/diskLogger";
 export const LOCAL_DOMAIN = "LOCAL";
 export const LOCAL_DOMAIN_PATH = getPathStr1(LOCAL_DOMAIN);
 
+if (!getOwnNodeId) {
+    devDebugbreak();
+}
+
+
 const POLL_RATE = 5000;
 const MAX_RECONNECT_TIME = timeInMinute * 15;
 const RECONNECT_POLL_INTERVAL = 10000;

package/src/0-path-value-core/archiveLocks/ArchiveLocks2.ts

@@ -8,12 +8,12 @@ import { Archives } from "../../-a-archives/archives";
 import debugbreak from "debugbreak";
 import { formatNumber, formatTime } from "socket-function/src/formatting/format";
 import { blue, green, magenta, red } from "socket-function/src/formatting/logColors";
-import { logNodeStateStats, logNodeStats } from "../../5-diagnostics/nodeMetadata";
 import { devDebugbreak } from "../../config";
 import { logErrors } from "../../errors";
 import { saveSnapshot } from "./archiveSnapshots";
 import { getNodeId } from "socket-function/src/nodeCache";
 import { diskLog } from "../../diagnostics/logs/diskLogger";
+import { logNodeStateStats, logNodeStats } from "../../-0-hooks/hooks";
 
 /** Clean up old files after a while */
 const DEAD_CREATE_THRESHOLD = timeInHour * 12;
@@ -57,7 +57,7 @@ export function createArchiveLocker2(config: {
 
         async setValue(key, value) {
             await getArchives(key).set(key, value);
-            logNodeStats(`archives|Created TΔ`, formatNumber)(1);
+            logNodeStats(`archives|Created TΔ`, formatNumber, 1);
         },
         async getValue(key) {
             return getArchives(key).get(key);
@@ -84,7 +84,7 @@ export function createArchiveLocker2(config: {
                     targetPath: key,
                     target: archiveRecycleBin,
                 });
-                logNodeStats(`archives|Deleted TΔ`, formatNumber)(1);
+                logNodeStats(`archives|Deleted TΔ`, formatNumber, 1);
             } catch {
                 // It was probably just moved by another process
             }
@@ -446,7 +446,7 @@ class TransactionLocker {
                         }
                     }
                     console.warn(message);
-                    logNodeStats(`archives|TΔ Atomic Retry`, formatNumber)(1);
+                    logNodeStats(`archives|TΔ Atomic Retry`, formatNumber, 1);
                     return false;
                 }
             }
@@ -557,7 +557,7 @@ class TransactionLocker {
         if (LOG) {
             console.log(`Applying transaction with ${createCount} creates and ${deleteCount} deletes. ${lockedFiles !== undefined && `Lock state depends on ${lockedFiles} files` || ""}`);
         }
-        logNodeStats(`archives|TΔ Apply`, formatNumber)(1);
+        logNodeStats(`archives|TΔ Apply`, formatNumber, 1);
         let opsRemaining = transaction.ops.slice();
         // NOTE: Order doesn't matter here. If anything is reading the values
         //  1) If it runs after we start, it will see our transaction and apply it
@@ -590,7 +590,7 @@ class TransactionLocker {
      */
     public async getFiles(): Promise<FileInfo[]> {
         let obj = await this.getFilesBase();
-        logNodeStateStats(`ArchiveLock Data File`, formatNumber)(obj.dataFiles.length);
+        logNodeStateStats(`ArchiveLock Data File`, formatNumber, obj.dataFiles.length);
         return obj.dataFiles;
     }
     private transactionAppliedCount = new Map<number, number>();
@@ -619,7 +619,7 @@ class TransactionLocker {
             });
             if (transactions.map(a => a.seqNum).join(",") !== transationsTest.map(a => a.seqNum).join(",")) {
                 console.warn("Transaction order is different when sorting by writeTime. This is likely due to a hanging writes.");
-                logNodeStats(`archives|TΔ Possible Hanging Write`, formatNumber)(1);
+                logNodeStats(`archives|TΔ Possible Hanging Write`, formatNumber, 1);
             }
         }
 
@@ -689,7 +689,7 @@ class TransactionLocker {
                     let unconfirmedOldFiles2 = veryOldFiles.filter(a => !doubleCheckLookup.has(a) && doubleCheckDataFiles.has(a.file));
                     console.warn(red(`Deleted ${unconfirmedOldFiles2.length} very old unconfirmed files`));
                     if (LOG) {
-                        logNodeStats(`archives|TΔ Delete Old Rejected File`, formatNumber)(unconfirmedOldFiles2.length);
+                        logNodeStats(`archives|TΔ Delete Old Rejected File`, formatNumber, unconfirmedOldFiles2.length);
                     }
                     // At the point the file was very old when we started reading, not part of the active transaction.
                     for (let file of unconfirmedOldFiles2) {
@@ -708,7 +708,7 @@ class TransactionLocker {
                 if (deprecatedFiles.length > 0) {
                     if (LOG) {
                         console.warn(red(`Deleted ${deprecatedFiles.length} / ${oldEnoughConfirms.length} confirmations, for not having corresponding data files`));
-                        logNodeStats(`archives|TΔ Delete Deprecated Confirm`, formatNumber)(deprecatedFiles.length);
+                        logNodeStats(`archives|TΔ Delete Deprecated Confirm`, formatNumber, deprecatedFiles.length);
                     }
                     for (let file of deprecatedFiles) {
                         await this.storage.deleteKey(file.file);
@@ -768,13 +768,13 @@ class TransactionLocker {
         //  which will cause our transaction to never apply. Otherwise... we MUST still
         //  be valid!
 
-        logNodeStats(`archives|TΔ Create File`, formatNumber)(1);
+        logNodeStats(`archives|TΔ Create File`, formatNumber, 1);
         await this.prepareTransaction(transaction);
 
         while (true) {
             let beforeData = await this.getFilesBase();
             if (!this.isTransactionValid(transaction, beforeData.dataFiles, beforeData.rawDataFiles)) {
-                logNodeStats(`archives|TΔ Rejected`, formatNumber)(1);
+                logNodeStats(`archives|TΔ Rejected`, formatNumber, 1);
                 if (LOG) {
                     console.log(red(`Finished transaction with rejection, ${transaction.ops.length} ops`));
                 }
@@ -785,7 +785,7 @@ class TransactionLocker {
 
             let afterData = await this.getFilesBase();
             if (this.wasTransactionApplied(transaction, afterData.dataFiles, afterData.rawDataFiles)) {
-                logNodeStats(`archives|TΔ Accepted`, formatNumber)(1);
+                logNodeStats(`archives|TΔ Accepted`, formatNumber, 1);
                 if (LOG) {
                     console.log(green(`Finished transaction with ${transaction.ops.length} ops`));
                 }

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

@@ -2,6 +2,7 @@ import { SocketFunction } from "socket-function/SocketFunction";
 import { requiresNetworkTrustHook } from "../-d-trust/NetworkTrust2";
 import { isDevDebugbreak } from "../config";
 import { measureWrap } from "socket-function/src/profiling/measure";
+import { QueueLimited } from "socket-function/src/misc";
 
 export interface DebugLog {
     type: string;
@@ -9,7 +10,6 @@ export interface DebugLog {
     values: { [key: string]: unknown };
 }
 
-const MAX_LOG_HISTORY = 1000 * 1000 * 10;
 let ENABLED_LOGGING = isDevDebugbreak();
 export function enableDebugLogging() {
     ENABLED_LOGGING = true;
@@ -23,18 +23,17 @@ export function isDebugLogEnabled() {
     return ENABLED_LOGGING;
 }
 
-let logHistory: DebugLog[] = [];
-let nextIndex = 0;
+let logHistory = new QueueLimited<DebugLog>(1000 * 1000 * 10);
 export function getFullLogHistory() {
     return logHistory;
 }
 export function getLogHistoryIncludes(includes: string) {
-    return logHistory.filter(x => {
+    return logHistory.getAllUnordered().filter(x => {
         return Object.values(x.values).some(y => String(y).includes(includes));
     });
 }
 export function getLogHistoryEquals(value: string) {
-    return logHistory.filter(x => {
+    return logHistory.getAllUnordered().filter(x => {
         return Object.values(x.values).some(y => y === value);
     });
 }
@@ -50,15 +49,7 @@ function debugLogBase(type: string, values: { [key: string]: unknown }) {
         return;
     }
     let newEntry: DebugLog = { type, time: Date.now(), values };
-    // NOTE: Use a rolling index. We don't promise our results are sorted, so this is fine.
-    //  ALSO, .shift to make a queue lags (it was making this function profile 90% of the time,
-    //  taking multiple seconds).
-    if (logHistory.length < MAX_LOG_HISTORY) {
-        logHistory.push(newEntry);
-    } else {
-        logHistory[nextIndex] = newEntry;
-        nextIndex = (nextIndex + 1) % MAX_LOG_HISTORY;
-    }
+    logHistory.push(newEntry);
 };
 
 class DebugLogControllerBase {
@@ -70,7 +61,7 @@ class DebugLogControllerBase {
     }
     public async getLogHistorySize() {
         return {
-            "logHistory.length": logHistory.length,
+            "logHistory.length": logHistory.getAllUnordered().length,
         };
     }
 }

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

@@ -13,7 +13,7 @@ import { batchFunction, delay, runInfinitePoll } from "socket-function/src/batch
 import { ActionsHistory } from "../diagnostics/ActionsHistory";
 import { markArrayAsSplitable } from "socket-function/src/fixLargeNetworkCalls";
 import { registerDynamicResource, registerMapArrayResource, registerResource } from "../diagnostics/trackResources";
-import { binarySearchIndex, isNode, isNodeTrue, promiseObj, timeInHour, timeInMinute, timeInSecond } from "socket-function/src/misc";
+import { binarySearchIndex, isNode, isNodeTrue, last, promiseObj, sort, timeInHour, timeInMinute, timeInSecond, QueueLimited } from "socket-function/src/misc";
 import { isNodeTrusted, isTrusted, isTrustedByNode } from "../-d-trust/NetworkTrust2";
 import { AuthorityPath, LOCAL_DOMAIN_PATH, pathValueAuthority2 } from "./NodePathAuthorities";
 import { pathValueSerializer } from "../-h-path-value-serialize/PathValueSerializer";
@@ -1115,15 +1115,22 @@ export const authorityStorage = new AuthorityPathValueStorage();
 // If PathValue, it is a local watch
 export type WriteCallback = NodeId | PathValue[];
 
+
 // isOwnNodeId(nodeId) means localOnValueCallback is called (instead of PathValueController.forwardWrites)
 export type PathWatcherCallback = NodeId;
 class PathWatcher {
-    //todonext;
-    // So... also record the watch start time, and the sync received time. So we can tell how long we waited
-    //  to sync each path. It's a bit annoying to do this at such a low level, but... how long it takes
-    //  to synchronize a path is probably the most important metric in the entire application. So... it's
-    //  fair to put it here.
-    private watchers = registerResource("paths|PathWatcher.watchers", new Map<string, Set<PathWatcherCallback>>());
+    private watchers = registerResource("paths|PathWatcher.watchers", new Map<string, {
+        watchers: Set<PathWatcherCallback>;
+        requestedTime: number;
+        receivedTime: number;
+    }>());
+    // If we don't limit the length, then this will memory leak. And if we only track
+    //  the values in watchers, then rolling key syncs will be lost.
+    private syncHistoryForHarvest = new QueueLimited<{ start: number; end: number; path: string; }>(1_000_000);
+    private syncHistoryForDebug = new QueueLimited<{ start: number; end: number; path: string; }>(1_000_000);
+
+    //private watchers = registerResource("paths|PathWatcher.watchers", new Map<string, Set<PathWatcherCallback>>());
+
     // realPath => packedPath => watcher => { depth, start, end }[]
     private parentWatchers = registerResource("paths|parentWatchers", new Map<string,
         // packedPath
@@ -1154,15 +1161,21 @@ class PathWatcher {
         let newPathsWatched = new Set<string>();
         let newParentsWatched = new Set<string>();
 
+        let time = Date.now();
+
         for (let path of config.paths) {
             let watchers = this.watchers.get(path);
             if (!watchers) {
-                watchers = new Set();
+                watchers = {
+                    watchers: new Set(),
+                    requestedTime: time,
+                    receivedTime: 0,
+                };
                 this.watchers.set(path, watchers);
             }
-            if (watchers.has(config.callback)) continue;
+            if (watchers.watchers.has(config.callback)) continue;
             newPathsWatched.add(path);
-            watchers.add(config.callback);
+            watchers.watchers.add(config.callback);
 
             let watchObj = this.watchersToPaths.get(config.callback);
             if (!watchObj) {
@@ -1264,8 +1277,8 @@ class PathWatcher {
 
             let watchers = this.watchers.get(path);
             if (!watchers) continue;
-            watchers.delete(callback);
-            if (watchers.size === 0) {
+            watchers.watchers.delete(callback);
+            if (watchers.watchers.size === 0) {
                 this.watchers.delete(path);
                 fullyUnwatched.paths.push(path);
                 authorityStorage.markPathAsUnwatched(path);
@@ -1312,7 +1325,7 @@ class PathWatcher {
             let watchers = this.watchers.get(path);
             if (watchers) {
                 this.watchers.delete(path);
-                for (let watcher of watchers) {
+                for (let watcher of watchers.watchers) {
                     let watchObj = this.watchersToPaths.get(watcher);
                     if (watchObj) {
                         watchObj.paths.delete(path);
@@ -1335,7 +1348,7 @@ class PathWatcher {
     }
 
     public triggerValuesChanged(valuesChanged: Set<PathValue>, parentsSynced?: string[], initialTriggers?: { values: Set<PathValue>; parentPaths: Set<string> }) {
-        let changedPerCallbacks = this.getWatchers(valuesChanged, parentsSynced);
+        let changedPerCallbacks = this.getWatchers(valuesChanged, { parentsSynced, pathsAreSynced: true });
         for (let [watch, changes] of changedPerCallbacks) {
             if (initialTriggers) {
                 let valuesFromInitialTrigger = new Set<PathValue>();
@@ -1371,11 +1384,24 @@ class PathWatcher {
             }
         }
     }
-    public getWatchers<T extends { path: string }>(valuesChanged: Set<T>, parentsSynced?: string[]) {
+    public getWatchers<T extends { path: string }>(
+        valuesChanged: Set<T>,
+        config?: {
+            parentsSynced?: string[];
+            pathsAreSynced?: boolean;
+        }
+    ) {
         let changedPerCallbacks: Map<PathWatcherCallback, Set<T>> = new Map();
+        let time = Date.now();
         for (let value of valuesChanged) {
             let path = value.path;
             let latestWatches = this.watchers.get(path);
+            if (config?.pathsAreSynced && latestWatches && !latestWatches.receivedTime) {
+                latestWatches.receivedTime = time;
+                let obj = { start: latestWatches.requestedTime, end: time, path };
+                this.syncHistoryForHarvest.push(obj);
+                this.syncHistoryForDebug.push(obj);
+            }
 
             function triggerNodeChanged(watcher: NodeId) {
                 let changes = changedPerCallbacks.get(watcher);
@@ -1387,7 +1413,7 @@ class PathWatcher {
             }
 
             if (latestWatches) {
-                for (let watch of latestWatches) {
+                for (let watch of latestWatches.watchers) {
                     triggerNodeChanged(watch);
                 }
             }
@@ -1411,7 +1437,7 @@ class PathWatcher {
                 }
             }
         }
-        for (let parentPath of parentsSynced ?? []) {
+        for (let parentPath of config?.parentsSynced ?? []) {
             let latestParentWatches = this.parentWatchers.get(parentPath);
             if (latestParentWatches) {
                 for (let { watchers } of latestParentWatches.values()) {
@@ -1504,6 +1530,16 @@ class PathWatcher {
     public getAllParentWatches() {
         return Array.from(this.parentWatchers.keys());
     }
+
+    public debug_harvestSyncTimes(): { start: number; end: number; path: string; }[] {
+        let times = this.syncHistoryForHarvest.getAllUnordered();
+        this.syncHistoryForHarvest.reset();
+        return times;
+    }
+
+    public debug_getSyncHistory(): { start: number; end: number; path: string; }[] {
+        return this.syncHistoryForDebug.getAllUnordered();
+    }
 }
 export const pathWatcher = new PathWatcher();
 

package/src/2-proxy/PathValueProxyWatcher.ts

@@ -32,8 +32,8 @@ import { DEPTH_TO_DATA, MODULE_INDEX, getCurrentCall, getCurrentCallObj } from "
 import { inlineNestedCalls } from "../3-path-functions/syncSchema";
 import { interceptCalls, runCall } from "../3-path-functions/PathFunctionHelpers";
 import { deepCloneCborx } from "../misc/cloneHelpers";
-import { addStatPeriodic, addTimeProfileDistribution, onTimeProfile } from "../5-diagnostics/nodeMetadata";
 import { formatPercent } from "socket-function/src/formatting/format";
+import { addStatPeriodic, onTimeProfile } from "../-0-hooks/hooks";
 
 // TODO: Break this into two parts:
 //  1) Run and get accesses
@@ -164,15 +164,23 @@ let harvestableReadyLoopCount = 0;
 let harvestableWaitingLoopCount = 0;
 let lastZombieCount = 0;
 // NOTE: Only the % waiting for active watchers. Which... is fine
-addStatPeriodic("Watcher % Waiting", () => {
-    let totalLoop = harvestableReadyLoopCount + harvestableWaitingLoopCount;
-    if (totalLoop === 0) return 0;
-    let frac = harvestableWaitingLoopCount / totalLoop;
-    harvestableWaitingLoopCount = 0;
-    harvestableReadyLoopCount = 0;
-    return frac;
-}, formatPercent);
-addStatPeriodic("Stalled Watchers", () => lastZombieCount);
+addStatPeriodic({
+    title: "Watcher % Waiting",
+    getValue: () => {
+        let totalLoop = harvestableReadyLoopCount + harvestableWaitingLoopCount;
+        if (totalLoop === 0) return 0;
+        let frac = harvestableWaitingLoopCount / totalLoop;
+        harvestableWaitingLoopCount = 0;
+        harvestableReadyLoopCount = 0;
+        return frac;
+    },
+    format: formatPercent,
+});
+addStatPeriodic({
+    title: "Stalled Watchers",
+    getValue: () => lastZombieCount,
+});
+
 
 //  Used to prevent local rejections on remote values (as local functions aren't rerun)
 //  Also used for security on servers, so they can read from untrusted domains, but can't have values

package/src/2-proxy/archiveMoveHarness.ts

@@ -9,9 +9,9 @@ import { AuthorityPath, pathValueAuthority2 } from "../0-path-value-core/NodePat
 import { FileInfo, ArchiveTransaction } from "../0-path-value-core/archiveLocks/ArchiveLocks";
 import { DecodedValuePath, pathValueArchives, PathValueArchives } from "../0-path-value-core/pathValueArchives";
 import { PathValue, VALUE_GC_THRESHOLD, FILE_VALUE_COUNT_LIMIT, FILE_SIZE_LIMIT, compareTime } from "../0-path-value-core/pathValueCore";
-import { logNodeStats } from "../5-diagnostics/nodeMetadata";
 import { getSingleSizeEstimate } from "../5-diagnostics/shared";
 import { getOurAuthorities } from "../config2";
+import { logNodeStats } from "../-0-hooks/hooks";
 import debugbreak from "debugbreak";
 
 // NOTE: We probably COULD load values with skipStrings+skipValues, for some GCers, as some
@@ -314,12 +314,12 @@ export async function runArchiveMover(config: {
                 + "\n=>\n"
                 + `    { files: ${formatNumber(outputFiles)}, values: ${formatNumber(outputValueCount)}, bytes: ${formatNumber(outputBytes)} }`
             );
-            logNodeStats("archives|Input Files", formatNumber)(time);
-            logNodeStats("archives|Input Values", formatNumber)(time);
-            logNodeStats("archives|Input Bytes", formatNumber)(time);
-            logNodeStats("archives|Output Files", formatNumber)(time);
-            logNodeStats("archives|Output Values", formatNumber)(time);
-            logNodeStats("archives|Output Bytes", formatNumber)(time);
+            logNodeStats("archives|Input Files", formatNumber, time);
+            logNodeStats("archives|Input Values", formatNumber, time);
+            logNodeStats("archives|Input Bytes", formatNumber, time);
+            logNodeStats("archives|Output Files", formatNumber, time);
+            logNodeStats("archives|Output Values", formatNumber, time);
+            logNodeStats("archives|Output Bytes", formatNumber, time);
         }
         console.log(" ");
     }

package/src/2-proxy/garbageCollection.ts

@@ -9,7 +9,7 @@ import { AuthorityPath, pathValueAuthority2 } from "../0-path-value-core/NodePat
 import { pathValueCommitter } from "../0-path-value-core/PathValueCommitter";
 import { ReadLock, epochTime, PathValue, authorityStorage, compareTime, getNextTime } from "../0-path-value-core/pathValueCore";
 import { WatchSpec, clientWatcher } from "../1-path-client/pathValueClientWatcher";
-import { logNodeStats } from "../5-diagnostics/nodeMetadata";
+import { logNodeStats } from "../-0-hooks/hooks";
 import { getPathFromStr, getPathStr } from "../path";
 import { PromiseObj } from "../promise";
 import { proxyWatcher, atomicRaw, atomic } from "./PathValueProxyWatcher";
@@ -634,9 +634,9 @@ export async function runAliveCheckerIteration(config?: {
                         console.log(`    currently unsynced paths ${formatNumber(paths.size)}, unsynced parent paths ${formatNumber(parentPaths.size)}`);
                         console.log(`    Total path watches ${formatNumber(watchSpec.paths.size)}, total parent path watches ${formatNumber(watchSpec.parentPaths.size)}`);
                         console.log(`    Total out of shard values ${formatNumber(outOfShardValues.size)}`);
-                        logNodeStats("archives|Unsynced Checkers", formatNumber)(paths.size);
-                        logNodeStats("archives|Unsynced Paths", formatNumber)(unsyncedPaths.size);
-                        logNodeStats("archives|Unsynced Parent Paths", formatNumber)(parentPaths.size);
+                        logNodeStats("archives|Unsynced Checkers", formatNumber, paths.size);
+                        logNodeStats("archives|Unsynced Paths", formatNumber, unsyncedPaths.size);
+                        logNodeStats("archives|Unsynced Parent Paths", formatNumber, parentPaths.size);
 
                         clientWatcher.setWatches(watchSpec);
 
@@ -656,7 +656,7 @@ export async function runAliveCheckerIteration(config?: {
                             }
                         }
                         console.log(green(`Free now: ${formatNumber(totalFreeCount)} / ${formatNumber(values.length)}`));
-                        logNodeStats("archives|Free now", formatNumber)(totalFreeCount);
+                        logNodeStats("archives|Free now", formatNumber, totalFreeCount);
                     }
                     {
                         let pendingFrees = gcRequests.size;
@@ -676,7 +676,7 @@ export async function runAliveCheckerIteration(config?: {
                             console.log(`    < ${day} days: ${formatNumber(count)}`);
                         }
 
-                        logNodeStats("archives|Stored future frees", formatNumber)(pendingFrees);
+                        logNodeStats("archives|Stored future frees", formatNumber, pendingFrees);
                     }
 
                     if (example.lockBasedDelete) {

package/src/4-dom/qreact.tsx

@@ -184,6 +184,7 @@ export class qreact {
     };
 
     public static getRenderingComponent = getRenderingComponent;
+    public static getRenderingComponentAssert = getRenderingComponentAssert;
     public static getAncestor = getAncestor;
     public static getAncestorProps = getAncestorProps;
     public static watchDispose = watchDispose;
@@ -329,9 +330,15 @@ function getCurrentComponentId() {
 function getRenderingComponent() {
     return QRenderClass.getInstanceAllowedUndefined(QRenderClass.renderingComponentId ?? -1) as ExternalRenderClass | undefined;
 }
+function getRenderingComponentAssert() {
+    let component = getRenderingComponent();
+    if (!component) throw new Error(`Can only call getRenderingComponentAssert if inside of a render function.`);
+    return component;
+}
 function getAncestorProps<Props>(
     componentClass: { new(...args: any[]): { props: Props } },
     component?: unknown
+
 ): Props | undefined {
     let id = (component as any)?.[idSymbol];
     let ancestor = getAncestor(componentClass, id);
@@ -351,7 +358,7 @@ function getAncestor(
 }
 function onDispose(fnc: () => void) {
     let component = getRenderingComponent();
-    if (!component) throw new Error(`Can watch dispose if not inside of a `);
+    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).`);
     watchDispose(component, fnc);
 }
 function watchDispose(renderClass: ExternalRenderClass, fnc: () => void) {

package/src/4-querysub/Querysub.ts

@@ -26,9 +26,6 @@ import { PermissionsCheck } from "./permissions";
 import { inlineNestedCalls, syncSchema } from "../3-path-functions/syncSchema";
 import type { identityStorageKey, IdentityStorageType } from "../-a-auth/certs";
 
-import "../diagnostics/watchdog";
-import "../diagnostics/trackResources";
-import "../diagnostics/benchmark";
 import { qreact } from "../4-dom/qreact";
 import { configRootDiscoveryLocation, getOwnNodeId } from "../-f-node-discovery/NodeDiscovery";
 import { pathValueCommitter } from "../0-path-value-core/PathValueCommitter";
@@ -53,6 +50,10 @@ import { isDynamicModule } from "../3-path-functions/pathFunctionLoader";
 
 export { t };
 
+if (!registerGetCompressNetwork) {
+    devDebugbreak();
+}
+
 
 export type MachineSourceCheck<T = unknown> = {
     /** NOTE: The source for this is added inline, and so it cannot use any external variables. */
@@ -873,4 +874,8 @@ setImmediate(() => {
 registerGetCompressNetwork(() => Querysub.COMPRESS_NETWORK);
 registerGetCompressDisk(() => Querysub.COMPRESS_DISK);
 
-(globalThis as any).Querysub = Querysub;
+(globalThis as any).Querysub = Querysub;
+
+import "../diagnostics/watchdog";
+import "../diagnostics/trackResources";
+import "../diagnostics/benchmark";