querysub 0.324.0 → 0.325.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.324.0",
+  "version": "0.325.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
@@ -37,7 +37,8 @@
     "depend": "yarn --silent depcruise src --include-only \"^src\" --config --output-type dot | dot -T svg > dependency-graph.svg",
     "test": "yarn typenode ./test.ts",
     "test3": "yarn typenode ./src/test/test.tsx --local",
-    "test2": "yarn typenode ./src/4-dom/qreactTest.tsx --local"
+    "test2": "yarn typenode ./src/4-dom/qreactTest.tsx --local",
+    "error-watch": "yarn typenode ./src/diagnostics/logs/errorNotifications/errorWatchEntry.tsx"
   },
   "bin": {
     "deploy": "./bin/deploy.js",

package/src/-a-auth/certs.ts

@@ -469,7 +469,8 @@ export function decodeNodeId(nodeId: string, allowMissingThreadId?: "allowMissin
         return undefined;
     }
     let parts = locationObj.address.split(".");
-    if (nodeId.startsWith("127-0-0-1.") && parts.length === 3) {
+    // NOTE: We have to only allow localhost domains on our port as the underlying domain gets stripped when we're looking at the machine ID, So if we allowed localhost domains on other domains, then it would potentially allow the possibility for a server to trick us to connecting to them. And then once the connection is established, it could talk back and we would think it has a localhost machine ID, which is implicitly trusted, which would then give it access to everything. 
+    if (nodeId.startsWith(`127-0-0-1.${getDomain()}`) && parts.length === 3 && nodeId.includes(":")) {
         return {
             threadId: "",
             machineId: parts.at(-3) || "",

package/src/-d-trust/NetworkTrust2.ts

@@ -92,10 +92,8 @@ const isTrustedBase = runInSerial(measureWrap(async function isTrustedBase(machi
     // Always trust ourself
     trustedCache.add(getOwnMachineId());
 
-    // NOTE: The only happens in the case WE connected to it (ex, "127-0-0-1.querysubtest.com:15358"). It can't look like this if it connected to us, in which case the nodeId will be "client:...", being mostly random, and created by us (UNTIL they prove they have another id). So... I'm not even sure the isPublic check is required? We only connect to nodes we discover through node discovery, which requires backblaze write permissions. But I guess it's fine to be extra careful about it...
-    if (!isPublic()) {
-        trustedCache.add("127-0-0-1");
-    }
+    // NOTE: This only happens to servers that we connect to. Also we only allow the machine ID to be this special ID in the case it's on our domain. And because we use HTTPS when connecting to domains, it means that it must be implicitly trusted if it has a certificate for our domain.
+    trustedCache.add("127-0-0-1");
 
     if (!trustedCache.has(machineId)) {
         untrustedCache.set(machineId, Date.now() + UNTRUST_CACHE_TIME);

package/src/-e-certs/EdgeCertController.ts

@@ -129,12 +129,21 @@ export async function publishMachineARecords() {
     let nodeObj = getNodeIdLocation(selfNodeId);
     if (!nodeObj) throw new Error(`Invalid nodeId ${selfNodeId}`);
     let machineAddress = nodeObj.address.split(".").slice(1).join(".");
-    await setRecord("A", machineAddress, ip);
-    await setRecord("A", "*." + machineAddress, ip);
+    let prevMachineIP = await getRecords("A", machineAddress);
     let ipDomain = await getIPDomain();
-    await setRecord("A", ipDomain, ip);
+    let promises: Promise<void>[] = [];
+    promises.push(setRecord("A", ipDomain, ip));
 
-    await publishEdgeDomain();
+
+    if (ip === "127.0.0.1" && prevMachineIP.length > 0 && !prevMachineIP.includes("127.0.0.1")) {
+        console.log(yellow(`Not setting A record for ${machineAddress} to ${ip}, as we previously had a public IP. IF you want to switch back to 127.0.0.1, manually go in and delete the A records for ${machineAddress}. Port forwarding should allow this to work anyways, and the bootstrapper should be smart enough to try 127-0-0-1 style addresses to allow fast development (ex, if you want to download a large file from the local development server quickly).`));
+    } else {
+        promises.push(setRecord("A", machineAddress, ip));
+        promises.push(setRecord("A", "*." + machineAddress, ip));
+    }
+
+    promises.push(publishEdgeDomain());
+    await Promise.all(promises);
 
     return {
         ip,

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

@@ -699,11 +699,15 @@ class TransactionLocker {
                     //  where backblaze returns no files? Which it might be doing, as multiple times this code has
                     //  triggered (without this check), and deletes all of our files...
                     let unconfirmedOldFiles2 = unconfirmedOldFiles.filter(a => !doubleCheckLookup.has(a.file) && doubleCheckDataFiles.has(a.file));
-                    console.warn(red(`Deleted ${unconfirmedOldFiles2.length} very old unconfirmed files`), { files: unconfirmedOldFiles2.map(x => x.file) });
-                    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) {
-                        await this.deleteDataFile(file.file, `old unconfirmed file`);
+                    if (unconfirmedOldFiles2.length > 0) {
+                        console.warn(red(`Deleted ${unconfirmedOldFiles2.length} very old unconfirmed files`), { files: unconfirmedOldFiles2.map(x => x.file) });
+                        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) {
+                            await this.deleteDataFile(file.file, `old unconfirmed file`);
+                        }
+                    } else {
+                        console.warn(`Almost deleted ${unconfirmedOldFiles.length} very old unconfirmed files. This is bad, did we miss their confirmations that first time? If we missed them twice in a row, we might literally delete the database, and need to enter recovery mode to fix it...`, { files: unconfirmedOldFiles });
                     }
                 }
             }

package/src/4-querysub/Querysub.ts

@@ -52,6 +52,7 @@ import yargs, { check } from "yargs";
 import { parseArgsFactory } from "../misc/rawParams";
 
 import * as typesafecss from "typesafecss";
+import "../library-components/urlResetGroups";
 
 
 typesafecss.setMeasureBlock(measureBlock);
@@ -72,6 +73,7 @@ let yargObj = parseArgsFactory()
     .option("verbosenetwork", { type: "boolean", desc: "Log all network activity" })
     .option("verboseframework", { type: "boolean", desc: "Log internal SocketFunction framework" })
     .option("nodelay", { type: "boolean", desc: "Don't delay committing functions, even ones that are marked to be delayed." })
+    .option("hot", { type: "boolean", desc: "force hot reloading to turn on even if public is true." })
     .argv
     ;
 setImmediate(() => {
@@ -724,7 +726,7 @@ export class Querysub {
         }
 
         // Hot reloading on public servers breaks things when we update (as the git pull triggers a hot reload), so... don't do that.
-        if (config.hotReload && !isPublic()) {
+        if (config.hotReload && !isPublic() || yargObj.hot) {
             watchFilesAndTriggerHotReloading();
         }
 

package/src/diagnostics/logs/FastArchiveAppendable.ts

@@ -348,7 +348,7 @@ export class FastArchiveAppendable<Datum> {
             endTime: number;
         };
         cacheBust: number;
-        wantData?: (posStart: number, posEnd: number, json: Buffer, file: FileMetadata) => boolean;
+        getWantData?: (file: FileMetadata) => Promise<((posStart: number, posEnd: number, data: Buffer) => boolean) | undefined>;
         onData: (datum: Datum[], file: FileMetadata) => void;
         // Called after onData
         onStats?: (stats: DatumStats, file: FileMetadata) => void;
@@ -365,7 +365,7 @@ export class FastArchiveAppendable<Datum> {
         };
         stopSynchronize: () => void;
     } | "cancelled"> {
-        let { wantData, onData, onStats } = config;
+        let { onData, onStats } = config;
         // Create unique client sync ID upfront
         let syncId = nextId();
 
@@ -525,12 +525,14 @@ export class FastArchiveAppendable<Datum> {
 
                 let scanProgressCount = 0;
 
+                const wantData = await config.getWantData?.(file);
+
                 function onParsedData(posStart: number, posEnd: number, buffer: Buffer | "done"): MaybePromise<void> {
                     if (buffer !== "done") {
                         scanProgressCount++;
                     }
                     if (buffer !== "done") {
-                        if (wantData && !wantData(posStart, posEnd, buffer, file)) {
+                        if (wantData && !wantData(posStart, posEnd, buffer)) {
                             notMatchedSize += (posEnd - posStart);
                             notMatchedCount++;
                             return;

package/src/diagnostics/logs/FastArchiveViewer.tsx

@@ -31,7 +31,7 @@ const caseInsensitiveParam = new URLParam("caseInsensitive", false);
 export class FastArchiveViewer<T> extends qreact.Component<{
     fastArchives: FastArchiveAppendable<T>[];
     onStart: () => void;
-    getWantData?: () => Promise<((posStart: number, posEnd: number, data: Buffer, file: FileMetadata) => boolean) | undefined>;
+    getWantData?: (file: FileMetadata) => Promise<((posStart: number, posEnd: number, data: Buffer) => boolean) | undefined>;
     onDatums: (source: FastArchiveAppendable<T>, datums: T[], metadata: FileMetadata) => void;
     // Called after onData
     onStats?: (source: FastArchiveAppendable<T>, stats: DatumStats, metadata: FileMetadata) => void;
@@ -103,7 +103,6 @@ export class FastArchiveViewer<T> extends qreact.Component<{
         let fastArchives = Querysub.fastRead(() => this.props.fastArchives);
         let onFinish = Querysub.fastRead(() => this.props.onFinish);
         let getWantData = Querysub.fastRead(() => this.props.getWantData);
-        let wantData = await getWantData?.();
         // Increment sequence number for this new sync attempt
         this.currentSequenceNumber++;
         this.latestSequenceNumber = this.currentSequenceNumber;
@@ -296,35 +295,37 @@ export class FastArchiveViewer<T> extends qreact.Component<{
                 const result = await fastArchive.synchronizeData({
                     range: timeRange,
                     cacheBust: Querysub.fastRead(() => cacheBustParam.value),
-                    wantData: (posStart: number, posEnd: number, data: Buffer, file) => {
-
-                        let isLimited = false;
-                        for (let i = posStart; i < posEnd && !isLimited; i++) {
-                            if (data[i] === limitedBuffer[0]) {
-                                for (let j = 1; j < limitedBuffer.length; j++) {
-                                    if (data[i + j] !== limitedBuffer[j]) {
-                                        break;
-                                    }
-                                    if (j === limitedBuffer.length - 1) {
-                                        isLimited = true;
-                                        break;
+                    getWantData: async (file) => {
+                        let wantData = await getWantData?.(file);
+                        return (posStart: number, posEnd: number, data: Buffer) => {
+                            let isLimited = false;
+                            for (let i = posStart; i < posEnd && !isLimited; i++) {
+                                if (data[i] === limitedBuffer[0]) {
+                                    for (let j = 1; j < limitedBuffer.length; j++) {
+                                        if (data[i + j] !== limitedBuffer[j]) {
+                                            break;
+                                        }
+                                        if (j === limitedBuffer.length - 1) {
+                                            isLimited = true;
+                                            break;
+                                        }
                                     }
                                 }
                             }
-                        }
-                        if (isLimited) {
-                            this.limitedScanCount++;
-                        }
+                            if (isLimited) {
+                                this.limitedScanCount++;
+                            }
 
-                        let matched = true;
-                        if (wantData) {
-                            matched = wantData(posStart, posEnd, data, file);
-                        }
-                        matched = matched && scanMatch(posStart, posEnd, data);
-                        if (isLimited && matched) {
-                            this.limitedMatchCount++;
-                        }
-                        return matched;
+                            // scanMatch is faster than wantData (generally), so run it first
+                            let matched = scanMatch(posStart, posEnd, data);
+                            if (matched && wantData) {
+                                matched = wantData(posStart, posEnd, data);
+                            }
+                            if (isLimited && matched) {
+                                this.limitedMatchCount++;
+                            }
+                            return matched;
+                        };
                     },
                     onData: (datums, file) => {
                         if (!isLatestSync()) return;
@@ -610,13 +611,23 @@ export class FastArchiveViewer<T> extends qreact.Component<{
                         </div>}
                         {!this.state.finished && <LoaderAurora />}
                         {this.limitedScanCount > 0 && (
-                            <div className={infoDisplay(60).boldStyle}>
-                                {formatNumber(this.limitedScanCount)} scanned logs were rate limited at a file level. We do not track how many were ignored, there might be infinite missing logs.
+                            <div className={infoDisplay(60).boldStyle.button}
+                                onClick={() => {
+                                    filterParam.value = LOG_LIMIT_FLAG;
+                                    void this.handleDownload();
+                                }}
+                            >
+                                Click here to see {formatNumber(this.limitedScanCount)} scanned logs were rate limited at a file level. We do not track how many were ignored, there might be infinite missing logs.
                             </div>
                         )}
-                        {this.limitedMatchCount > 0 && (
-                            <div className={infoDisplay(0).boldStyle}>
-                                {formatNumber(this.limitedMatchCount)} matched logs were rate limited at a file level. We do not track how many were ignored, there might be infinite missing logs.
+                        {this.limitedMatchCount > 0 && filterParam.value && (
+                            <div className={infoDisplay(0).boldStyle.button}
+                                onClick={() => {
+                                    filterParam.value += " & " + LOG_LIMIT_FLAG;
+                                    void this.handleDownload();
+                                }}
+                            >
+                                Click here to see {formatNumber(this.limitedMatchCount)} matched logs were rate limited at a file level. We do not track how many were ignored, there might be infinite missing logs.
                             </div>
                         )}
                         {this.state.pendingSyncInitializations > 0 && (

package/src/diagnostics/logs/LogViewer2.tsx

@@ -13,7 +13,7 @@ import { logErrors } from "../../errors";
 import { batchFunction, runInSerial } from "socket-function/src/batching";
 import { Querysub } from "../../4-querysub/QuerysubController";
 import { sort, timeInDay, timeInHour } from "socket-function/src/misc";
-import { FastArchiveViewer } from "./FastArchiveViewer";
+import { FastArchiveViewer, filterParam } from "./FastArchiveViewer";
 import { LogDatum, getLoggers, LOG_LIMIT_FLAG } from "./diskLogger";
 import { ColumnType, Table, TableType } from "../../5-diagnostics/Table";
 import { formatDateJSX } from "../../misc/formatJSX";
@@ -24,7 +24,7 @@ import { ObjectDisplay } from "./ObjectDisplay";
 import { endTime } from "../misc-pages/archiveViewerShared";
 import { ErrorSuppressionUI } from "./errorNotifications/ErrorSuppressionUI";
 import { FileMetadata } from "./FastArchiveController";
-import { SuppressionListController, getSuppressEntryChecker } from "./errorNotifications/ErrorNotificationController";
+import { SuppressionListController, getSuppressEntryChecker, getSuppressionFull } from "./errorNotifications/ErrorNotificationController";
 import { SocketFunction } from "socket-function/SocketFunction";
 
 const RENDER_INTERVAL = 1000;
@@ -56,6 +56,7 @@ export class LogViewer2 extends qreact.Component {
     });
 
     private example: string | undefined = undefined;
+    private operationSequenceNum = 0;
     private datumCount = 0;
     private matchedSize = 0;
     private notMatchedSize = 0;
@@ -100,6 +101,10 @@ export class LogViewer2 extends qreact.Component {
             }
         }
 
+        let suppressionController = SuppressionListController(SocketFunction.browserNodeId());
+        let suppressionList = suppressionController.getSuppressionList();
+        let hasErrorNotifyToggle = errorNotifyToggleURL.value;
+
         const timeRange = getTimeRange();
         return (
             <div className={css.vbox(20).pad2(20).fillBoth}>
@@ -114,6 +119,7 @@ export class LogViewer2 extends qreact.Component {
                                 let now = Date.now();
                                 startTimeParam.value = now - timeInDay * 7;
                                 endTimeParam.value = now + timeInHour * 2;
+                                filterParam.value = "";
                             }
                             this.rerun();
                         }}
@@ -148,40 +154,34 @@ export class LogViewer2 extends qreact.Component {
                         this.datums = [];
                         this.suppressionCounts = new Map();
                         this.expiredSuppressionCounts = new Map();
-                    }}
-                    getWantData={async () => {
-                        if (!Querysub.fastRead(() => errorNotifyToggleURL.value)) return undefined;
-                        let suppressionList = await SuppressionListController(SocketFunction.browserNodeId()).getSuppressionList.promise();
-                        let now = Date.now();
-                        // Newest first, so when we add a new entry we can see what it matches, even if it takes it away from older entries
-                        sort(suppressionList, x => -x.lastUpdateTime);
-                        let checkers = suppressionList.map(x => getSuppressEntryChecker(x));
-                        this.suppressionCounts = new Map(suppressionList.map(x => [x.key, 0]));
-                        this.expiredSuppressionCounts = new Map(suppressionList.map(x => [x.key, 0]));
-                        let updateCounts = batchFunction({ delay: 1000 }, () => {
-                            Querysub.commit(() => {
-                                this.state.datumsSeqNum++;
-                            });
-                        });
-                        return (posStart, posEnd, data, file) => {
-                            for (let checker of checkers) {
-                                if (checker.fnc(data, posStart, posEnd)) {
-                                    if (checker.entry.expiresAt < now) {
-                                        let count = this.expiredSuppressionCounts.get(checker.entry.key) || 0;
-                                        count++;
-                                        this.expiredSuppressionCounts.set(checker.entry.key, count);
-                                        void updateCounts(undefined);
-                                    } else {
-                                        let count = this.suppressionCounts.get(checker.entry.key) || 0;
-                                        count++;
-                                        this.suppressionCounts.set(checker.entry.key, count);
-                                        void updateCounts(undefined);
-                                        return false;
-                                    }
+                        this.operationSequenceNum++;
+                        void (async () => {
+                            const currentSequenceNum = this.operationSequenceNum;
+                            while (true) {
+                                await new Promise(resolve => setTimeout(resolve, 1000));
+                                if (this.operationSequenceNum !== currentSequenceNum) {
+                                    break;
                                 }
+                                Querysub.commit(() => {
+                                    this.state.datumsSeqNum++;
+                                });
                             }
-                            return true;
-                        };
+                        })();
+                    }}
+                    getWantData={async (file) => {
+                        if (!hasErrorNotifyToggle) return undefined;
+                        // By defaulting to the synchronous one, the list will be updated if there's any changes. However, we will also just get it asynchronously if the list hasn't been updated by the time we call get1data. And because we assign it back to the variable, it'll be cached. 
+                        suppressionList = suppressionList || await suppressionController.getSuppressionList.promise();
+                        let suppressionFull = getSuppressionFull({
+                            entries: suppressionList,
+                            blockTimeRange: {
+                                startTime: file.startTime,
+                                endTime: file.endTime,
+                            },
+                            suppressionCounts: this.suppressionCounts,
+                            expiredSuppressionCounts: this.expiredSuppressionCounts,
+                        });
+                        return suppressionFull;
                     }}
                     onDatums={(source, datums, file) => {
                         this.datumCount += datums.length;
@@ -212,6 +212,7 @@ export class LogViewer2 extends qreact.Component {
                         }
                     }}
                     onFinish={() => {
+                        this.operationSequenceNum++;
                         Querysub.commit(() => {
                             sort(this.datums, x => -(x.time || 0));
                             this.state.datumsSeqNum++;

package/src/diagnostics/logs/TimeRangeSelector.tsx

@@ -82,10 +82,26 @@ export class TimeRangeSelector extends qreact.Component {
                     >
                         Set to future data
                     </Button>
-                    {(endTimeParam.value || startTimeParam.value) && <Button
+                    <Button
+                        hue={110} onClick={() => {
+                            startTimeParam.value = now - timeInDay;
+                            endTimeParam.value = now + timeInHour * 2;
+                        }}
+                    >
+                        Set to last day
+                    </Button>
+                    <Button
+                        hue={110} onClick={() => {
+                            startTimeParam.value = now - timeInDay * 7;
+                            endTimeParam.value = now + timeInHour * 2;
+                        }}
+                    >
+                        Set to last 7 days
+                    </Button>
+                    {!!(endTimeParam.value || startTimeParam.value) && <Button
                         hue={110} onClick={resetToLastDay}
                     >
-                        Reset to Last Day
+                        Reset
                     </Button>}
                     {(!startTimeParam.value || !endTimeParam.value) && <Button
                         hue={110}

package/src/diagnostics/logs/errorNotifications/ErrorNotificationController.ts

@@ -109,74 +109,201 @@ export const getSuppressEntryChecker = cacheLimited(
     }
 );
 
+export const getSuppressionFull = measureWrap(function getSuppressionFull(config: {
+    entries: SuppressionEntry[];
+    blockTimeRange: {
+        startTime: number;
+        endTime: number;
+    };
+    suppressionCounts?: Map<string, number>;
+    expiredSuppressionCounts?: Map<string, number>;
+    // => wants data
+}): ((posStart: number, posEnd: number, data: Buffer, obj?: { outdatedSuppressionKey?: string }) => boolean) {
+    let { entries, blockTimeRange } = config;
+    const { suppressionCounts, expiredSuppressionCounts } = config;
+    // Add some buffer, just in case entries get added a bit later, or early.
+    let startTime = blockTimeRange.startTime - timeInHour;
+    let endTime = blockTimeRange.endTime + timeInHour;
+
+    sort(entries, x => -x.lastUpdateTime);
+
+    let checkers = entries.map(x => getSuppressEntryChecker(x));
+
+    let definitelyNotExpired = checkers.filter(x => x.entry.expiresAt > endTime);
+    let definitelyExpired = checkers.filter(x => x.entry.expiresAt < startTime);
+    let maybeExpired = checkers.filter(x => x.entry.expiresAt >= startTime && x.entry.expiresAt <= endTime);
+
+    return (posStart, posEnd, data, obj) => {
+        let suppressed = false;
+        for (let checker of definitelyNotExpired) {
+            if (checker.fnc(data, posStart, posEnd)) {
+                if (!suppressionCounts && !expiredSuppressionCounts && !obj) {
+                    return false;
+                }
+                suppressed = true;
+                if (!suppressionCounts) break;
+
+                let count = suppressionCounts.get(checker.entry.key) || 0;
+                count++;
+                suppressionCounts.set(checker.entry.key, count);
+            }
+        }
+
+        // Handle definitelyExpired - these are outdated suppressions
+        let mostRecentOutdatedSuppressionKey: string | undefined = undefined;
+
+        // Handle maybeExpired - need to parse timestamp to check if suppression was active
+        if (maybeExpired.length > 0 && (suppressionCounts || expiredSuppressionCounts || obj)) {
+            const getLogTime = () => {
+                try {
+                    let logEntry = JSON.parse(data.slice(posStart, posEnd).toString()) as LogDatum;
+                    return typeof logEntry.time === "number" ? logEntry.time : 0;
+                } catch {
+                    return 0;
+                }
+            };
+            let logTime = getLogTime();
+
+            for (let checker of maybeExpired) {
+                if (checker.fnc(data, posStart, posEnd)) {
+                    if (checker.entry.expiresAt >= logTime) {
+                        suppressed = true;
+                        if (suppressionCounts) {
+                            let count = suppressionCounts.get(checker.entry.key) || 0;
+                            count++;
+                            suppressionCounts.set(checker.entry.key, count);
+                        }
+                    } else {
+                        if (!mostRecentOutdatedSuppressionKey) {
+                            mostRecentOutdatedSuppressionKey = checker.entry.key;
+                        }
+                        // Even if we don't want the expired suppression counts, we might want the normal suppression counts, so we have to keep going. 
+                        if (expiredSuppressionCounts) {
+                            let count = expiredSuppressionCounts.get(checker.entry.key) || 0;
+                            count++;
+                            expiredSuppressionCounts.set(checker.entry.key, count);
+                        }
+                    }
+                }
+            }
+        }
+
+        if (expiredSuppressionCounts || obj) {
+            for (let checker of definitelyExpired) {
+                if (checker.fnc(data, posStart, posEnd)) {
+                    // First match is the most recent (entries are sorted by lastUpdateTime desc)
+                    if (!mostRecentOutdatedSuppressionKey) {
+                        mostRecentOutdatedSuppressionKey = checker.entry.key;
+                    }
+                    if (!expiredSuppressionCounts) break;
+                    let count = expiredSuppressionCounts.get(checker.entry.key) || 0;
+                    count++;
+                    expiredSuppressionCounts.set(checker.entry.key, count);
+                }
+            }
+        }
+
+        // Set the most recent outdated suppression key if we found any and weren't suppressed
+        if (obj && mostRecentOutdatedSuppressionKey && !suppressed) {
+            obj.outdatedSuppressionKey = mostRecentOutdatedSuppressionKey;
+        }
+
+        return !suppressed;
+    };
+});
+
 
 const suppressionListKey = "suppression-list.json";
 const suppressionListArchive = archiveJSONT<SuppressionListBase>(() =>
     getArchives("suppression-list"),
 );
+const suppressionUpdatedChannel = new SocketChannel<boolean>("suppression-updated");
 
 class SuppressionList {
+    private init = lazy(async () => {
+        suppressionUpdatedChannel.watch(() => {
+            void this.updateEntriesNow();
+        });
+    });
+    private updateEntriesNow = async () => {
+        let entries = await suppressionListArchive.get(suppressionListKey);
+        if (!entries) {
+            entries = { entries: {} };
+        }
+        this.getEntries.set(Promise.resolve(entries));
+    };
     private getEntries = lazy(async (): Promise<SuppressionListBase> => {
+        await this.init();
         await runInfinitePollCallAtStart(SUPPRESSION_POLL_INTERVAL, async () => {
-            let entries = await suppressionListArchive.get(suppressionListKey);
-            if (!entries) {
-                entries = { entries: {} };
-            }
-            await suppressionListArchive.set(suppressionListKey, entries);
-            this.getEntries.set(Promise.resolve(entries));
+            await this.updateEntriesNow();
         });
         // Infinite poll will have set this, so we don't infinitely loop
         return await this.getEntries();
     });
 
     public async filterObjsToNonSuppressed(objs: LogDatum[]): Promise<LogDatum[]> {
-        // NOTE: Streamed data should be rare enough
+        // NOTE: Streamed data should be rare enough, that handling this inefficiently is okay.
+        if (objs.length === 0) return [];
+        let startTime = objs[0].time;
+        let endTime = objs[objs.length - 1].time;
         let parts: Buffer[] = [];
         for (let obj of objs) {
             parts.push(Buffer.from(JSON.stringify(obj)));
             parts.push(objectDelimitterBuffer);
+            if (obj.time < startTime) {
+                startTime = obj.time;
+            }
+            if (obj.time > endTime) {
+                endTime = obj.time;
+            }
         }
         let buffer = Buffer.concat(parts);
-        let scanner = await this.scanForRecentErrors();
+        let scanner = await this.scanForRecentErrors({
+            startTime,
+            endTime,
+        });
         await scanner.onData(buffer);
         return await scanner.finish();
     }
-    public async scanForRecentErrors(): Promise<{
+    public async scanForRecentErrors(config: {
+        startTime: number;
+        endTime: number;
+    }): Promise<{
         onData: (data: Buffer) => void;
         finish: () => Promise<LogDatum[]>;
     }> {
         let entries = await this.getEntries();
-        let now = Date.now();
-        let checkers = Object.values(entries.entries)
-            .map(entry => getSuppressEntryChecker(entry))
-            ;
+        let suppressionFull = getSuppressionFull({
+            entries: Object.values(entries.entries),
+            blockTimeRange: {
+                startTime: config.startTime,
+                endTime: config.endTime,
+            },
+        });
         let datums: LogDatum[] = [];
+        // Create an object which we'll reuse that will be the output object for the suppression key. 
+        // for the suppression key. 
+        let obj: { outdatedSuppressionKey?: string } = {};
         let callback = createLogScanner({
             onParsedData: (posStart, posEnd, buffer) => {
                 if (buffer === "done") {
                     return;
                 }
-                let outdatedSuppressionKey: string | undefined = undefined;
-                for (let checker of checkers) {
-                    if (checker.fnc(buffer, posStart, posEnd)) {
-                        if (checker.entry.expiresAt < now) {
-                            outdatedSuppressionKey = checker.entry.key;
-                            continue;
-                        }
-                        return;
-                    }
-                }
-                let obj: LogDatum;
+                let result = suppressionFull(posStart, posEnd, buffer, obj);
+
+                if (!result) return;
+
+                let datum: LogDatum;
                 try {
-                    obj = JSON.parse(buffer.slice(posStart, posEnd).toString()) as LogDatum;
+                    datum = JSON.parse(buffer.slice(posStart, posEnd).toString()) as LogDatum;
                 } catch (e: any) {
                     process.stderr.write(`Failed to parse log datum in around ${buffer.slice(posStart, posEnd).slice(0, 100).toString("hex")}, error is:\n${e.stack}`);
                     return;
                 }
-                if (outdatedSuppressionKey) {
-                    obj.__matchedOutdatedSuppressionKey = outdatedSuppressionKey;
+                if (obj.outdatedSuppressionKey) {
+                    datum.__matchedOutdatedSuppressionKey = obj.outdatedSuppressionKey;
                 }
-                datums.push(obj);
+                datums.push(datum);
             },
         });
         let lastWaitTime = Date.now();
@@ -201,13 +328,15 @@ class SuppressionList {
         let entries = await this.getEntries();
         entry.lastUpdateTime = Date.now();
         entries.entries[entry.key] = entry;
-        await suppressionListArchive.set(suppressionListKey, entries);
+        void suppressionListArchive.set(suppressionListKey, entries);
+        suppressionUpdatedChannel.broadcast(true);
         await recentErrors.onSuppressionChanged();
     }
     public async removeSuppressionEntry(key: string) {
         let entries = await this.getEntries();
         delete entries.entries[key];
-        await suppressionListArchive.set(suppressionListKey, entries);
+        void suppressionListArchive.set(suppressionListKey, entries);
+        suppressionUpdatedChannel.broadcast(true);
         await recentErrors.onSuppressionChanged();
     }
 
@@ -378,7 +507,9 @@ const limitRecentErrors = measureWrap(function limitRecentErrors(objs: LogDatum[
 class RecentErrors {
 
     private initialize = lazy(async () => {
-        errorWatcherBase.watch(x => this.addErrors(x));
+        errorWatcherBase.watch(x => {
+            void this.addErrors(x);
+        });
         await this.scanNow({});
         runInfinitePoll(BACKBLAZE_POLL_INTERVAL, async () => {
             await this.scanNow({ noLocalFiles: true });
@@ -415,6 +546,7 @@ class RecentErrors {
     });
 
     private async addErrors(objs: LogDatum[]) {
+        if (objs.length === 0) return;
         for (let obj of objs) {
             this._recentErrors.push(obj);
         }
@@ -464,7 +596,10 @@ class RecentErrors {
                     let hash = getFileMetadataHash(file);
                     path = await urlCache.getURLLocalPath(file.url, hash);
                     if (!path) continue;
-                    let scanner = await suppressionList.scanForRecentErrors();
+                    let scanner = await suppressionList.scanForRecentErrors({
+                        startTime: file.startTime,
+                        endTime: file.endTime,
+                    });
 
                     // Stream decompress the file while reading it
                     size = await fs.promises.stat(path).then(x => x.size);
@@ -554,7 +689,7 @@ export const RecentErrorsController = getSyncedController(SocketFunction.registe
     },
 });
 
-const recentErrorsChannel = new SocketChannel<true>("recent-errors-eeceb0c8-4086-4ab3-b3ff-fa9fd5282e14");
+export const recentErrorsChannel = new SocketChannel<true>("recent-errors-eeceb0c8-4086-4ab3-b3ff-fa9fd5282e14");
 
 export const watchRecentErrors = lazy(function watchRecentErrors() {
     recentErrorsChannel.watch(async () => {
@@ -571,7 +706,9 @@ export const notifyWatchersOfError = batchFunction({
 },
     async (objs: LogDatum[]) => {
         objs = await suppressionList.filterObjsToNonSuppressed(objs);
-        errorWatcherBase.broadcast(objs);
+        if (objs.length > 0) {
+            errorWatcherBase.broadcast(objs);
+        }
     }
 );
 

package/src/diagnostics/logs/errorNotifications/ErrorSuppressionUI.tsx

@@ -60,7 +60,7 @@ export class ErrorSuppressionUI extends qreact.Component<{
         const previewMatchCount = this.calculatePreviewMatchCount(this.state.matchedInput);
 
         return <div className={css.vbox(16).pad2(16).fillWidth.bord2(0, 0, 50, 5).hsl(0, 0, 80)}>
-            <h2 className={css.fontSize(18).marginTop(0)}>Error Suppression List</h2>
+            <div className={css.fontSize(18)}>Error Suppression List ({formatNumber(entries.length)})</div>
 
             <div className={css.hbox(8).fillWidth}>
                 <InputLabel
@@ -133,7 +133,7 @@ export class ErrorSuppressionUI extends qreact.Component<{
                         });
                     });
                 }}>
-                    Not an error
+                    Not a bug
                 </Button>
             </div>
 
@@ -192,22 +192,28 @@ export class ErrorSuppressionUI extends qreact.Component<{
                             Ignore (for a week)
                         </Button>
                         <Button onClick={() => updateEntry({ expiresAt: NOT_AN_ERROR_EXPIRE_TIME })}>
-                            Not an error
+                            Not a bug
                         </Button>
                         <Button
                             onClick={() => updateEntry({ expiresAt: Date.now() - timeInDay * 7 })}
-                            title="Unignore"
+                            title="Unignore, so past errors show up again as errors"
                         >
                             Unignore
                         </Button>
+                        <Button
+                            onClick={() => updateEntry({ expiresAt: Date.now() })}
+                            title="Set ignore time to now, so any future errors will receive notifications"
+                        >
+                            Ignore previous
+                        </Button>
                         {entry.expiresAt === NOT_AN_ERROR_EXPIRE_TIME && <span>
-                            Not an error
+                            Not a bug
                         </span>}
                         {entry.expiresAt < Date.now() && <span>
-                            Expired
+                            Expired {formatDateJSX(entry.expiresAt)}
                         </span>}
                         {entry.expiresAt > Date.now() && entry.expiresAt !== NOT_AN_ERROR_EXPIRE_TIME && <span>
-                            Expires in {formatDateJSX(Date.now() * 2 - entry.expiresAt)}
+                            Expires {formatDateJSX(entry.expiresAt)}
                         </span>}
                         <span className={css.opacity(0.5)}>
                             (Last Updated: {formatDateJSX(entry.lastUpdateTime)})

package/src/diagnostics/logs/errorNotifications/ErrorWarning.tsx

@@ -10,9 +10,12 @@ import { ATag } from "../../../library-components/ATag";
 import { managementPageURL, showingManagementURL } from "../../managementPages";
 import { errorNotifyToggleURL } from "../LogViewer2";
 import { Querysub } from "../../../4-querysub/QuerysubController";
-import { nextId, timeInDay } from "socket-function/src/misc";
+import { nextId, timeInDay, timeInHour } from "socket-function/src/misc";
 import { formatNumber } from "socket-function/src/formatting/format";
 import { Icon } from "../../../library-components/icons";
+import { filterParam } from "../FastArchiveViewer";
+import { endTimeParam, startTimeParam } from "../TimeRangeSelector";
+import { formatDateJSX } from "../../../misc/formatJSX";
 
 export class ErrorWarning extends qreact.Component {
     state = t.state({
@@ -64,9 +67,18 @@ export class ErrorWarning extends qreact.Component {
                 </style>
             </Button>;
 
+        const logLink = [
+            showingManagementURL.getOverride(true),
+            managementPageURL.getOverride("LogViewer2"),
+            errorNotifyToggleURL.getOverride(true),
+            filterParam.getOverride(""),
+            startTimeParam.getOverride(Date.now() - timeInDay * 7),
+            endTimeParam.getOverride(Date.now() + timeInHour * 2),
+        ];
+
         if (!recentErrors || recentErrors.length === 0) {
             return <span className={css.hbox(8)}>
-                <ATag target="_blank" values={[showingManagementURL.getOverride(true), managementPageURL.getOverride("LogViewer2"), errorNotifyToggleURL.getOverride(true)]}>
+                <ATag target="_blank" values={logLink}>
                     No Errors
                 </ATag>
                 {refreshButton}
@@ -112,7 +124,7 @@ export class ErrorWarning extends qreact.Component {
                         ⚠️ {fileCountText} files with errors
                     </div>
 
-                    <ATag target="_blank" values={[showingManagementURL.getOverride(true), managementPageURL.getOverride("LogViewer2"), errorNotifyToggleURL.getOverride(true)]}>
+                    <ATag target="_blank" values={logLink}>
                         View Logs
                     </ATag>
                     {refreshButton}
@@ -139,7 +151,7 @@ export class ErrorWarning extends qreact.Component {
                     </div>
                 }
                 <div className={css.hbox(8).hsl(0, 50, 50).pad2(4, 2).colorhsl(0, 50, 95)}>
-                    {recentErrors[0].param0} ({recentErrors[0].__NAME__})
+                    ({formatDateJSX(recentErrors[0].time)}) {recentErrors[0].param0} ({recentErrors[0].__NAME__})
                 </div>
 
                 <div className={css.hbox(8).fillWidth}>

package/src/diagnostics/logs/errorNotifications/errorWatchEntry.tsx

@@ -0,0 +1,63 @@
+import { batchFunction, runInfinitePollCallAtStart } from "socket-function/src/batching";
+import { getControllerNodeId } from "../../../-g-core-values/NodeCapabilities";
+import { RecentErrorsController, recentErrorsChannel, watchRecentErrors } from "./ErrorNotificationController";
+import { timeInSecond } from "socket-function/src/misc";
+import { formatDateTime } from "socket-function/src/formatting/format";
+
+
+//todonext
+
+
+// 5) Add a channel to watch suppression entries, as once we suppress it, we don't want notifications anymore anywhere, And we don't want to have to wait
+//      - test by logging when we get errors and then having our script which automatically keeps adding errors to keep running so we can verify that we keep logging new errors and then ignore the errors and this suppression should propagate and cause us to no longer omit the errors.
+//      - This will also cause the errors to be suppressed across different HTTP servers. 
+
+// 5) Get IMs actually sending. 
+
+// 6) Set up all the code to properly rate limit IMs, batch them, link back to the log page, etc. 
+//      - Just link to the error page for the last week. We don't need to link to anything specific. 
+//      - properly getting the node ID that we're going to be watching, and if it goes down, getting a new one, and ignoring messages from the old node. 
+//      - And if no node exists, we need to warn and then wait. 
+
+// 7) Write the digest script, which is very different, but will run in the same entry.
+//      - Separate warnings and errors and also bucket by time bucket 
+// 8) Write a page that shows the results of the digest in tabs, writing the digest probably just to backblaze 
+//      - For now, just have two tabs, one for errors and one for warnings. 
+//      - If we're going to do a full scan, we might as well show time series data as well. It's trivial. 
+//      - Also track the number of suppressed errors as well. We won't have details on these such as a breakdown, but we can at least show the count (and the count by time)
+// 9) send an email every time period, and also send an IM that has smaller information
+//      - Both will link to the actual web page that has the digest, deep linking to the specific tabs. 
+//      - Show the chart in the email as well, but just format it like ASCII Because image dependencies are annoying and I don't want to implement them right now as it might take a few days to get working. 
+
+async function runIMNotifies() {
+    let controllerNodeId = await getControllerNodeId(RecentErrorsController.base);
+    if (!controllerNodeId) throw new Error("No controller node id found");
+    //todonext
+    //  Temporary hardcode to use the local server
+    controllerNodeId = "127-0-0-1.querysubtest.com:7007";
+
+    let controller = RecentErrorsController.base.nodes[controllerNodeId];
+    recentErrorsChannel.watch(() => {
+        void updateRecentErrors(undefined);
+    });
+    const updateRecentErrors = batchFunction(
+        //todonext
+        //  Increase this after we finish testing
+        { delay: 1000 },
+        async function updateRecentErrors() {
+            let recentErrors = await controller.getRecentErrors();
+            console.log(`Received ${recentErrors.length} recent errors at ${formatDateTime(Date.now())}`);
+            for (let error of recentErrors) {
+                console.log(`    ${error.param0}`);
+            }
+            console.log();
+            console.log();
+        }
+    );
+    await updateRecentErrors(undefined);
+}
+
+async function main() {
+    void runIMNotifies();
+}
+void main();

package/src/diagnostics/logs/lifeCycleAnalysis/spec.md

@@ -4,34 +4,6 @@ Very small amount of data
     https://127-0-0-1.querysubtest.com:7007/?hot&enableLogs&page=login&filter=%22431%22&showingmanagement&endTime=1755140880000&startTime=1754950020000&managementpage=LogViewer2
 
 
-3) Our time range is not being correctly applied. We have data from 4-5, and are filtering from 4:25 to 5:32, and not matching that data, even though it overlaps a lot.
-4) API watchers are repeatedly dying. I feel like this is fixable, especially with our logs...
-
-5) Update all services, and move them to that machine
-5) Verify the hezner server can run the site well
-6) Take down our digital ocean server
-7) Destroy our digital ocean server
-
-9) Add a filter to JUST see rate limited logs (by clicking on the button. which just searches for the special text)
-    - say "click here to view rate limited logs"
-
-10) "Started Listening" isn't being logged?
-    - https://127-0-0-1.querysubtest.com:7007/?enableLogs&page=login&showingmanagement&endTime=1757835685102.667&managementpage=LogViewer2&machineview=service-detail&startTime=1757745685102.667&serviceId=service-1756340309836&filter=__machineId%20%3D%20a794fbcf7b104c68%20%26%20Edge
-    - Or... maybe logs are lost SOMETIMES, and ALWAYS when we kill the server? Although... that would mean we have multiple issues. Ugh...
-
-11) API ranges overlapped? What? I think our code to pick an empty range is wrong?
-
-6) Update URLParam to allow linking it to other parameters, resetting when they change.
-    - With a function, and have standard one beside URLParam (that uses page and tab)
-        - ALSO managementPageURL
-    - Reset filter in FastArchiveViewer
-        - First observe the overlap with it and the BookOverview
-        - If we are actually on the book overview page and we close the management page then that shouldn't reset it. We just want to reset it when you change pages. Because we want you to be able to hide and show the management page quickly if you want to double check something. Generally speaking though, you won't be on a page with filter and then going back and forth. And if you are, whatever. That's just the management page. We just want to avoid the overall confusion and annoyance of having lots of pre-filled values (And mostly the confusion of having filter prefilled all the time because it's always going to be set because everyone uses it and no one resets it at the moment. 
-    - DON'T reset tab. It's useful to remember the tab? Hmm... sometimes at least...
-
-
-
-
 5) IM error notifications - allow immediately knowing about production issues, for better testing
     - Create a dedicated entry point which acts like a client of the HTTP server, using RecentErrorControllers.getRecentErrors
         - Getting it working in a script will be interesting, but... in theory it should just work?
@@ -62,6 +34,25 @@ Very small amount of data
 
 
 5) Life cycle analyzer
+    - Implement regular range lifecycles first (matching an === object field)
+        - THEN, Add lifecycle collections where we can define life cycles that have a certain type. 
+            - A collection that has everything by default and we remove life cycles from it would also be useful.
+        - AFTER that, MAYBE, support global values, setting them, and referencing them in the life cycle (which makes them shown as a whole, AND on each line in the life cycle, so we can see the progression).
+            - We have to allow selecting the value we want as well based on a lifecycle state that it can set with its logs. And then we're basically building expression. The whole thing becomes very complicated. So maybe we won't even do it. 
+            - We should definitely wait until we create life cycles and find use out of them before we start adding global values. 
+    - It seems like life cycles have two types. 
+        1) Set global values for user in other logs
+            - Allows for providing specific context, such as what are all the nodes that exist at this time, What are all the paths, authorities that exist, etc, So we can tell what the results should be by essentially knowing what the other values are on other servers inst... antly in a way that the current node couldn't possibly know at that time (And because it can't know it, it couldn't log it. So it's the only way to get this information).
+        2) Range based, a bunch of values connected via an === object field, making one range
+            - allows reducing the complexity of an analysis, by taking lots of different logs and reducing it to just one.. 
+                - IMPORTANT! Show the time and the count of logs in the life cycle.  
+                - also allows us to look at them as a whole, as in how long did it take. Which is minor because we could just measure it, However, sometimes it's annoying to pass the start time information around And if we don't pass the start time around, then we need to look at the start time from the first log and the end time for the last log, which again, would require looking at it as a lifecycle analysis. 
+            - allows adding information based on the existence or the non-existence of a log in that group, such as A setup process missing the last step. 
+                - IMPORTANT! we need to support this by allowing defining life cycles as requiring certain field value combinations which we will end up making basically just the field will always be type and the value will be the type in that life cycle and we'll hard code all the steps that are required and then we can warn when there's a missing step
+                    - I guess also show the count of every single step because that's useful to see if some things were repeated. 
+            - Allows drilling into a lifecycle to see just the specific information of the lifecycle cross server
+                - Otherwise, it's somewhat annoying to look at things cross-server, and while we can search for a specific key that we log, which is exactly what life cycles will do, it's easier to just click to drilldown, rather than having to make the query dynamically every time we want it. 
+        2.1) Collections of life cycles so we can further reduce the complexity. 
     - Uses FastArchiveViewer, but instead of showing a table, shows lifecycles (a derived concept)
         - We save them in backblaze, with a bit of cache for loading them
     - List of life cycles

package/src/diagnostics/managementPages.tsx

@@ -230,7 +230,8 @@ export async function isManagementUser() {
         debugName: "isManagementUser",
         call: testCall,
     });
-    return !!writes.result;
+    let isTrustedResult = !!writes.result;
+    return isTrustedResult;
 }
 
 export async function assertIsManagementUser() {

package/src/functional/SocketChannel.ts

@@ -4,6 +4,8 @@ import { getAllNodeIds, watchNodeIds } from "../-f-node-discovery/NodeDiscovery"
 import { requiresNetworkTrustHook } from "../-d-trust/NetworkTrust2";
 import { errorToUndefinedSilent } from "../errors";
 import { assertIsManagementUser } from "../diagnostics/managementPages";
+import { IdentityController_getCurrentReconnectNodeId, IdentityController_getMachineId } from "../-c-identity/IdentityController";
+import { blue } from "socket-function/src/formatting/logColors";
 
 export class SocketChannel<T> {
     constructor(private globalUniqueChannelName: string) { }
@@ -34,7 +36,9 @@ export class SocketChannel<T> {
     private remoteWatchers = new Set<string>();
     public async _internal_watchMessages() {
         let caller = SocketFunction.getCaller();
+        let callerNodeId = IdentityController_getCurrentReconnectNodeId();
         this.remoteWatchers.add(caller.nodeId);
+        console.info(blue(`New watcher for channel ${this.globalUniqueChannelName} from ${caller.nodeId} (${callerNodeId})`));
         SocketFunction.onNextDisconnect(caller.nodeId, () => {
             this.remoteWatchers.delete(caller.nodeId);
         });
@@ -44,7 +48,7 @@ export class SocketChannel<T> {
         void Array.from(this.remoteWatchers).map(async (nodeId) => {
             try {
                 await this.controller.nodes[nodeId]._internal_onMessage(message);
-            } catch {
+            } catch (e) {
                 this.remoteWatchers.delete(nodeId);
             }
         });

package/src/library-components/ATag.tsx

@@ -2,6 +2,7 @@ import preact from "preact";
 import { css, isNode } from "typesafecss";
 import { URLParam, parseSearchString, encodeSearchString } from "./URLParam";
 import { qreact } from "../4-dom/qreact";
+import { niceStringify } from "../niceStringify";
 
 export type URLOverride<T = unknown> = {
     param: URLParam<T>;

package/src/library-components/SyncedController.ts

@@ -40,11 +40,11 @@ onHotReload(() => {
 export function syncedIsAnyLoading() {
     return Querysub.fastRead(() => {
         for (let controllerId in syncedData()) {
-            for (let fncs of Object.values(syncedData()[controllerId])) {
-                for (let fnc of Object.values(fncs)) {
+            for (let [nodeId, fncs] of Object.entries(syncedData()[controllerId])) {
+                for (let [fncName, fnc] of Object.entries(fncs)) {
                     for (let obj of Object.values(fnc)) {
                         if (atomic(obj.promise)) {
-                            return true;
+                            return `${fncName} (on ${nodeId})`;
                         }
                     }
                 }
@@ -109,6 +109,7 @@ export function getSyncedController<T extends SocketRegistered>(
     resetAll(): void;
     refreshAll(): void;
     isAnyLoading(): boolean;
+    base: T;
 } {
     if (isNode()) {
         let result = cache((nodeId: string) => {
@@ -160,6 +161,7 @@ export function getSyncedController<T extends SocketRegistered>(
         result.isAnyLoading = () => {
             notAllowedOnServer();
         };
+        result.base = controller;
         return result;
     }
     let id = nextId();
@@ -404,5 +406,6 @@ export function getSyncedController<T extends SocketRegistered>(
             }
         });
     };
+    result.base = controller;
     return result;
 }

package/src/library-components/SyncedControllerLoadingIndicator.tsx

@@ -7,7 +7,8 @@ export class SyncedControllerLoadingIndicator extends qreact.Component {
     timeLastLoaded = Date.now();
     lastWasLoaded = false;
     render() {
-        if (!syncedIsAnyLoading()) {
+        let loadingPath = syncedIsAnyLoading();
+        if (!loadingPath) {
             if (!this.lastWasLoaded) {
                 console.log(`Loaded all SyncedController calls in ${formatTime(Date.now() - this.timeLastLoaded)}`);
             }
@@ -33,7 +34,7 @@ export class SyncedControllerLoadingIndicator extends qreact.Component {
                     .borderRadius("50%")
                 + " " + spinAnimationClass
             }></div>
-            <span>Syncing data...</span>
+            <span title={loadingPath}>Syncing data...</span>
             <style>
                 {`
                     @keyframes ${spinAnimationClass} {

package/src/library-components/URLParam.ts

@@ -34,16 +34,37 @@ if (!isNode()) {
     loadSearchCache = parseSearchString(location.search);
 }
 
+declare global {
+    var urlResetLinks: Map<string, Set<string>>;
+}
+// changed => reset
+let resetLinks: Map<string, Set<string>> = globalThis.urlResetLinks || (globalThis.urlResetLinks = new Map());
+
 
 export class URLParam<T = unknown> {
-    constructor(urlKey: string, defaultValue: T) {
-        return createURLSync(urlKey, defaultValue);
+    constructor(urlKey: string, defaultValue: T, config?: URLParamConfig) {
+        return createURLSync(urlKey, defaultValue, config);
     }
 }
-/** const myVariable = createURLSync("myvar", 0) */
-export function createURLSync<T>(urlKey: string, defaultValue: T, config?: {
+export type URLParamConfig = {
     storage?: "url" | "localStorage";
-}): URLParam<T> {
+    // Reset when any of these urlKeys change
+    reset?: { (): { urlKey: string }[] }[];
+};
+/** const myVariable = createURLSync("myvar", 0) */
+export function createURLSync<T>(urlKey: string, defaultValue: T, config?: URLParamConfig): URLParam<T> {
+    setImmediate(() => {
+        for (let reset of config?.reset || []) {
+            for (let resetSource of reset()) {
+                let lookup = resetLinks.get(resetSource.urlKey);
+                if (!lookup) {
+                    lookup = new Set();
+                    resetLinks.set(resetSource.urlKey, lookup);
+                }
+                lookup.add(urlKey);
+            }
+        }
+    });
 
     let prev = globalURLLookup[urlKey];
     if (prev) {
@@ -104,6 +125,15 @@ export function createURLSync<T>(urlKey: string, defaultValue: T, config?: {
             }
         },
         set value(value: T) {
+            let resetTargets = resetLinks.get(urlKey);
+            if (resetTargets) {
+                for (let resetTarget of resetTargets) {
+                    let param = globalURLLookup[resetTarget];
+                    if (param) {
+                        param.reset();
+                    }
+                }
+            }
             if (!proxyWatcher.inWatcher()) {
                 Querysub.commit(() => {
                     param.value = value;

package/src/library-components/niceStringify.ts

@@ -10,7 +10,7 @@ let specialStringValuesEncode = new Map([...specialStringValuesDecode].map(([key
 export function serializeURLParam(value: unknown): string | undefined {
     if (value === true) return undefined;
     // If it is a string and doesn't look JSON encoded, then just use it raw.
-    if (typeof value === "string" && !lookJSONEncoded(value)) {
+    if (typeof value === "string" && !lookJSONEncoded(value) && value !== "") {
         return value;
     }
     let specialValue = specialStringValuesEncode.get(value);

package/src/library-components/urlResetGroups.ts

@@ -0,0 +1,14 @@
+import { URLParam, URLParamConfig } from "./URLParam";
+
+
+export const pageURL = new URLParam("page", "");
+export const tabURL = new URLParam("tab", "");
+export const managementPageURL = new URLParam("managementpage", "");
+
+export const filterURL = new URLParam("filter", "", { reset: [mainResets] });
+export const startTimeURL = new URLParam("startTime", 0, { reset: [mainResets] });
+export const endTimeURL = new URLParam("endTime", 0, { reset: [mainResets] });
+
+export function mainResets(): URLParam[] {
+    return [pageURL, tabURL, managementPageURL];
+}

package/src/misc/formatJSX.tsx

@@ -1,6 +1,12 @@
 import { qreact } from "../4-dom/qreact";
 import { formatTime, formatVeryNiceDateTime } from "socket-function/src/formatting/format";
+import { Querysub } from "../4-querysub/QuerysubController";
 
 export function formatDateJSX(time: number) {
-    return <span title={formatVeryNiceDateTime(time)}>{formatTime(Date.now() - time)}</span>;
+    let diff = time - Querysub.nowDelayed(10 * 1000);
+    let ago = diff < 0;
+    if (ago) {
+        diff = -diff;
+    }
+    return <span title={formatVeryNiceDateTime(time)}>{!ago && "IN "}{formatTime(diff)}{ago && " AGO"}</span>;
 }

package/testEntry2.ts

@@ -3,13 +3,23 @@ import { getOwnMachineId } from "./src/-a-auth/certs";
 import { getOwnThreadId } from "./src/-f-node-discovery/NodeDiscovery";
 import { shutdown } from "./src/diagnostics/periodic";
 import { testTCPIsListening } from "socket-function/src/networking";
+import { Querysub } from "./src/4-querysub/QuerysubController";
+import { timeInSecond } from "socket-function/src/misc";
 
 export async function testMain() {
-    let test = await testTCPIsListening("1.1.1.1", 443);
-    console.log(test);
-    // await delay(0);
+    Querysub;
+    //let test = await testTCPIsListening("1.1.1.1", 443);
+    //console.log(test);
+    // Writing heartbeat 2025/09/14 08:37:46 PM for self (5ac8a2fa78fce4ea.971ed8b01743d123.querysubtest.com:13900)
+    await delay(timeInSecond);
+    await Querysub.hostService("test");
+    await delay(timeInSecond * 5);
     // console.log(getOwnThreadId());
-    // console.error(`Test warning for ErrorWarning testing`);
+    // Log an error every 30 seconds forever. 
+    while (true) {
+        console.error(`Test warning for im testing ${Date.now()}`);
+        await delay(timeInSecond * 30);
+    }
     // console.log(getOwnThreadId());
     // await shutdown();
     //await Querysub.hostService("test");
@@ -24,7 +34,8 @@ export async function testMain() {
     //     }
     //     await testLogs.flushNow();
     // }
-    // await shutdown();
+    await delay(timeInSecond * 15);
+    await shutdown();
 }
 async function main() {