querysub 0.402.0 → 0.404.0

package/src/diagnostics/logs/lifeCycleAnalysis/NestedLifeCycleInfo.tsx

@@ -1,55 +1,42 @@
 import { SocketFunction } from "socket-function/SocketFunction";
 import { css } from "typesafecss";
-import { t } from "../../../2-proxy/schema2";
 import { qreact } from "../../../4-dom/qreact";
-import { formatValue } from "../../../5-diagnostics/GenericFormat";
-import { Button } from "../../../library-components/Button";
-import { niceStringify } from "../../../niceStringify";
-import { LogDatum } from "../diskLogger";
-import { LifeCycle, LifeCyclesController, getVariables } from "./lifeCycles";
-import { createLifeCycleSearch, LifecycleInstance } from "./lifeCycleSearch";
-import { IndexedLogResults } from "../IndexedLogs/BufferIndexHelpers";
+import { LifeCycle, LifeCycleEntry, LifeCyclesController } from "./lifeCycles";
 import { formatSearchString } from "../IndexedLogs/LogViewerParams";
-import { getPathStr, getPathStr2 } from "../../../path";
+import { ATag } from "../../../library-components/ATag";
+import { lifecycleIdURL, limitURL, additionalSearchURL, phase2AdditionalSearchURL } from "./LifeCyclePage";
 
 export class NestedLifeCycleInfo extends qreact.Component<{
     keyName: string;
     value: unknown;
-    aliases: string[];
+    entry: LifeCycleEntry;
     currentLifeCycleId: string;
 }> {
-    state = t.state({
-        searchingLifeCycleId: t.atomic<string | undefined>(undefined),
-        phase1Results: t.atomic<LogDatum[]>([]),
-        phase1InvalidResults: t.atomic<Array<{ datum: LogDatum; missingKeys: string[] }>>([]),
-        phase1Stats: t.atomic<IndexedLogResults | undefined>(undefined),
-        phase1Searching: t.boolean(false),
-        phase2Results: t.atomic<LogDatum[]>([]),
-        phase2Stats: t.atomic<IndexedLogResults | undefined>(undefined),
-        phase2Searching: t.boolean(false),
-        phase2HitLimit: t.boolean(false),
-        lifecycleInstances: t.atomic<LifecycleInstance[]>([]),
-    });
-
     controller = LifeCyclesController(SocketFunction.browserNodeId());
-    search = createLifeCycleSearch(this);
 
     render() {
         let lifeCycles = this.controller.getLifeCycles();
         if (!lifeCycles) return null;
 
-        let { keyName, value, aliases, currentLifeCycleId } = this.props;
+        let { keyName, value, entry, currentLifeCycleId } = this.props;
+
+        let isGroupByKey = Array.isArray(entry.groupByKeys) && entry.groupByKeys.some(k => k.ourKey === keyName);
+        let aliases = isGroupByKey && entry.groupByKeys.find(k => k.ourKey === keyName)?.aliases || entry.variables[keyName]?.aliases || [];
 
         let allKeysToMatch = [keyName, ...aliases].filter(x => !["__threadId", "__machineId"].includes(x));
         let matchingLifeCycles: Array<{ lifecycle: LifeCycle; matchedKey: string }> = [];
 
         for (let lifecycle of lifeCycles) {
-            if (lifecycle.id === currentLifeCycleId) continue;
+            let keySources = allKeysToMatch;
+            // Don't match our keyName if we are the same lifecycle
+            if (lifecycle.id === currentLifeCycleId) {
+                keySources = aliases;
+            }
 
             let matchedKey: string | undefined = undefined;
             for (let entry of lifecycle.entries) {
                 for (let groupByKey of entry.groupByKeys) {
-                    if (allKeysToMatch.includes(groupByKey.ourKey)) {
+                    if (keySources.includes(groupByKey.ourKey)) {
                         matchedKey = groupByKey.ourKey;
                         break;
                     }
@@ -66,85 +53,20 @@ export class NestedLifeCycleInfo extends qreact.Component<{
 
         return <>
             {matchingLifeCycles.map(({ lifecycle, matchedKey }) => {
-                let isSearchingThis = this.state.searchingLifeCycleId === lifecycle.id;
-                let isSearching = isSearchingThis && (this.state.phase1Searching || this.state.phase2Searching);
-                let hasSearched = isSearchingThis && !isSearching;
-
-                let instances = hasSearched && this.state.lifecycleInstances.filter(inst =>
-                    inst.keys.some(k => k.key === matchedKey && k.value === value)
-                ) || [];
-                let hasResults = instances.length > 0;
-
-                let progressText = "";
-                if (isSearching && isSearchingThis) {
-                    let parts: string[] = [];
-
-                    if (this.state.phase1Searching || this.state.phase1Stats) {
-                        let stats = this.state.phase1Stats;
-                        let blocksScanned = stats && (stats.localFilesSearched + stats.backblazeFilesSearched) || 0;
-                        let resultsCount = this.state.phase1Results.length;
-                        parts.push(`${blocksScanned} > ${resultsCount}`);
-                    }
-
-                    if (this.state.phase2Searching) {
-                        let stats = this.state.phase2Stats;
-                        let blocksScanned = stats && (stats.localFilesSearched + stats.backblazeFilesSearched) || 0;
-                        let resultsCount = this.state.phase2Results.length;
-                        parts.push(`${blocksScanned} > ${resultsCount}`);
-                    }
-
-                    progressText = parts.length > 0 && `(${parts.join(" | ")})` || "(...)";
-                }
-
-                return <>
-                    <Button
-                        hue={180}
-                        onClick={() => {
-                            void this.search.searchLifeCycle({
-                                lifeCycleId: lifecycle.id,
-                                limit: 10,
-                                additionalSearch: formatSearchString({ [matchedKey]: value })
-                            });
-                        }}
-                    >
-                        {lifecycle.title} {isSearching && "⏳" || ""} {progressText} {hasSearched && `(${instances.length})` || ""}
-                    </Button>
-                    {hasSearched && !hasResults && (
-                        <div className={css.pad2(4).colorhsl(0, 0, 50)}>No results found</div>
-                    )}
-                    {hasResults && (() => {
-                        let firstInstance = instances[0];
-                        let totalCount = instances.length;
-                        let hitLimit = totalCount >= 10;
-
-                        let keys = lifecycle.entries.map(x => x.groupByKeys.map(y => y.ourKey).concat(Object.keys(x.variables))).flat();
-
-                        function valueHash(key: string, value: unknown) {
-                            return getPathStr2(key, String(value));
-                        }
-                        let values = new Map<string, { key: string; value: unknown }>();
-                        for (let entry of firstInstance.entries) {
-                            for (let [key, value] of Object.entries(entry.datum)) {
-                                if (!keys.includes(key)) continue;
-                                if (key === matchedKey) continue;
-                                if (["__threadId", "__machineId"].includes(key)) continue;
-                                values.set(valueHash(key, value), { key, value });
-                            }
-                        }
-
-                        return <>
-                            <div className={css.hbox(4)}>
-                                {hitLimit && <span className={css.colorhsl(30, 80, 40).boldStyle}>(hit limit!)</span>}
-                            </div>
-                            {Array.from(values.values()).map(({ key, value }, idx) => (
-                                <div key={idx} className={css.hbox(4)}>
-                                    <span className={css.colorhsl(200, 50, 60).boldStyle}>{key}:</span>
-                                    <span className={css.colorhsl(0, 0, 50)}>{niceStringify(value)}</span>
-                                </div>
-                            ))}
-                        </>;
-                    })()}
-                </>;
+                let additionalSearch = formatSearchString({ [matchedKey]: value });
+
+                return <ATag
+                    key={lifecycle.id}
+                    values={[
+                        lifecycleIdURL.getOverride(lifecycle.id),
+                        limitURL.getOverride(10),
+                        additionalSearchURL.getOverride(additionalSearch),
+                        phase2AdditionalSearchURL.getOverride("")
+                    ]}
+                    className={css.pad2(8, 4).hsl(180, 60, 90).hslhover(180, 60, 85).colorhsl(180, 80, 30).textDecoration("none").borderRadius(4).display("inline-block")}
+                >
+                    {lifecycle.title}
+                </ATag>;
             })}
         </>;
     }

package/src/diagnostics/logs/lifeCycleAnalysis/lifeCycleMatching.ts

@@ -42,6 +42,8 @@ export function getLifecycleMatchesForDatum(
                 entry,
                 datum: extractedDatum,
             });
+            // For now, this is fine. Sometimes we actually have overlapping entries, which is bad, but doesn't really matter, And if we don't break here, we'll get multiple matches. And all of our entries have the same group by keys and variables anyway, so if we match one, it's the same as matching all of them. 
+            break;
         }
     }
 

package/src/diagnostics/logs/lifeCycleAnalysis/lifeCycleSearch.tsx

@@ -89,9 +89,10 @@ export function createLifeCycleSearch(
     let searchLifeCycle = async (params: {
         lifeCycleId: string;
         additionalSearch: string;
+        phase2AdditionalSearch: string;
         limit: number;
     }) => {
-        let { lifeCycleId, additionalSearch, limit } = params;
+        let { lifeCycleId, additionalSearch, phase2AdditionalSearch, limit } = params;
         let lifeCycles = await context.controller.getLifeCycles.promise();
         if (!lifeCycles) return;
 
@@ -128,6 +129,7 @@ export function createLifeCycleSearch(
             lifeCycle,
             phase1Results,
             currentSequenceNumber,
+            phase2AdditionalSearch,
             limit,
         });
 
@@ -164,10 +166,13 @@ export function createLifeCycleSearch(
             resetPhase1State();
         });
 
-        let searchQuery = startEntries.map(entry => entry.matchPattern).join("|");
-        if (additionalSearch) {
-            searchQuery = searchQuery + "&" + additionalSearch;
-        }
+        let searchQuery = startEntries.map(entry => {
+            let pattern = entry.matchPattern;
+            if (additionalSearch) {
+                pattern = pattern + "&" + additionalSearch;
+            }
+            return pattern;
+        }).join("|");
         let searchBuffer = Buffer.from(searchQuery, "utf8");
 
         let sourceTypes = new Set<string>();
@@ -298,9 +303,10 @@ export function createLifeCycleSearch(
         lifeCycle: LifeCycle;
         phase1Results: LogDatum[];
         currentSequenceNumber: number;
+        phase2AdditionalSearch: string;
         limit: number;
     }): Promise<{ results: LogDatum[]; hitLimit: boolean }> => {
-        let { lifeCycle, phase1Results, currentSequenceNumber, limit } = params;
+        let { lifeCycle, phase1Results, currentSequenceNumber, phase2AdditionalSearch, limit } = params;
 
         if (phase1Results.length === 0) {
             return { results: [], hitLimit: false };
@@ -411,7 +417,12 @@ export function createLifeCycleSearch(
                 sourceType === "warning" && loggers.warnLogs ||
                 loggers.errorLogs;
 
-            let searchQuery = Array.from(queries).join("|");
+            let searchQuery = Array.from(queries).map(query => {
+                if (phase2AdditionalSearch) {
+                    return query + "&" + phase2AdditionalSearch;
+                }
+                return query;
+            }).join("|");
             let searchBuffer = Buffer.from(searchQuery, "utf8");
 
             let results: LogDatum[] = [];

package/src/diagnostics/logs/lifeCycleAnalysis/lifeCycles.tsx

@@ -15,6 +15,9 @@ export type LifeCycle = {
     entries: LifeCycleEntry[];
 };
 
+// TODO: Actually, maybe we should make it so the group by keys and the variables are just in the life cycle, as we keep wanting them to be identical for all the entries. It would be a pretty simple refactor. Although we would have to retrofit the old data, But then again, we could just have the AI create a script for that...
+// IF we do any changes, we SHOULD refactor it so we have the same groupByKeys and variables
+//      - Aliases for variables is very useful, and for group by keys. However, start key is not needed. We're never going to use that. We'll just change the logging code to log the key that we want. 
 export type LifeCycleEntry = {
     description?: string;
 

package/src/diagnostics/managementPages.tsx

@@ -13,7 +13,6 @@ import { t } from "../../src/2-proxy/schema2";
 import { SocketRegistered } from "socket-function/SocketFunctionTypes";
 import { nextId } from "socket-function/src/misc";
 import { IdentityController_getSecureIP, IdentityController_getMachineId } from "../-c-identity/IdentityController";
-import { LOCAL_DOMAIN } from "../0-path-value-core/PathController";
 import { getNextTime } from "../0-path-value-core/pathValueCore";
 import { encodeArgs } from "../3-path-functions/PathFunctionHelpers";
 import { CallSpec, getCurrentCall, getCurrentCallAllowUndefined, overrideCurrentCall } from "../3-path-functions/PathFunctionRunner";
@@ -28,6 +27,7 @@ import { addComponentButton } from "../5-diagnostics/qreactDebug";
 import { closeAllModals } from "../5-diagnostics/Modal";
 import { delay } from "socket-function/src/batching";
 import { currentViewParam, selectedServiceIdParam } from "../deployManager/urlParams";
+import { FunctionCallInfo } from "./FunctionCallInfo";
 
 export const managementPageURL = new URLParam("managementpage", "");
 export const showingManagementURL = new URLParam("showingmanagement", false);
@@ -87,7 +87,7 @@ export async function registerManagementPages2(config: {
         getModule: () => import("./NodeViewer"),
     });
     inputPages.push({
-        title: "Logs3",
+        title: "LOG VIEWER",
         componentName: "LogViewer3",
         getModule: () => import("./logs/IndexedLogs/LogViewer3"),
     });
@@ -142,6 +142,12 @@ export async function registerManagementPages2(config: {
         componentName: "RequireAuditPage",
         getModule: () => import("./misc-pages/RequireAuditPage"),
     });
+    inputPages.push({
+        title: "Sync Test",
+        componentName: "SyncTestPage",
+        controllerName: "SyncTestController",
+        getModule: () => import("./SyncTestPage"),
+    });
     inputPages.push(...config.pages);
 
     // NOTE: We don't store the UI in the database (here, or anywhere else, at least
@@ -343,7 +349,7 @@ class ManagementRoot extends qreact.Component {
                         <ATag values={[
                             managementPageURL.getOverride("MachinesPage"),
                             currentViewParam.getOverride("services"),
-                        ]}>Deploy Machines</ATag>
+                        ]}>Deploy Framework</ATag>
                         <ATag values={[
                             managementPageURL.getOverride("MachinesPage"),
                             currentViewParam.getOverride("deploy"),
@@ -351,6 +357,7 @@ class ManagementRoot extends qreact.Component {
                         {pages.map(page =>
                             <ATag values={[{ param: managementPageURL, value: page.componentName }]}>{page.title}</ATag>
                         )}
+                        <FunctionCallInfo />
                     </div>
                     {currentPage &&
                         <div

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

@@ -1,28 +1,24 @@
 import { DecodedValuePath, PathValueArchives, pathValueArchives } from "../../0-path-value-core/pathValueArchives";
 import { SocketFunction } from "socket-function/SocketFunction";
-import { AuthorityPath } from "../../0-path-value-core/NodePathAuthorities";
-import preact from "preact"; import { qreact } from "../../4-dom/qreact";
+import { qreact } from "../../4-dom/qreact";
 import { logErrors } from "../../errors";
 import { getBrowserUrlNode } from "../../-f-node-discovery/NodeDiscovery";
-import { getPathFromStr, getPathStr, getPathStr1, isValidPathStr, rootPathStr } from "../../path";
-import { getDomain } from "../../config";
+import { rootPathStr } from "../../path";
 import { css } from "typesafecss";
-import { cacheArgsEqual, cacheJSONArgsEqual, cacheLimited, cacheShallowConfigArgEqual, lazy } from "socket-function/src/caching";
+import { cacheArgsEqual, cacheLimited, cacheShallowConfigArgEqual, lazy } from "socket-function/src/caching";
 import { atomic, atomicObjectWrite, atomicObjectWriteNoFreeze, doAtomicWrites, proxyWatcher } from "../../2-proxy/PathValueProxyWatcher";
 import { Querysub } from "../../4-querysub/QuerysubController";
 import { formatDate, formatDateTime, formatNumber, formatPercent, formatTime } from "socket-function/src/formatting/format";
-import { getSeededRandom } from "../../misc/random";
 import { Histogram, XYValue } from "../../library-components/Histogram";
 import { Button } from "../../library-components/Button";
 import { createURLSync } from "../../library-components/URLParam";
-import { Input } from "../../library-components/Input";
-import { deepCloneJSON, nextId, sort, throttleFunction, timeInDay } from "socket-function/src/misc";
-import { isDefined, isEmpty } from "../../misc";
-import { PathValue, Time, authorityStorage, epochTime } from "../../0-path-value-core/pathValueCore";
+import { sort, throttleFunction } from "socket-function/src/misc";
+import { isEmpty } from "../../misc";
+import { PathValue, epochTime } from "../../0-path-value-core/pathValueCore";
 import { pathValueSerializer } from "../../-h-path-value-serialize/PathValueSerializer";
-import { InputLabel, InputLabelURL } from "../../library-components/InputLabel";
-import { addEpsilons, getLowUint32, getShortNumber } from "../../bits";
-import { measureBlock, measureFnc, measureWrap } from "socket-function/src/profiling/measure";
+import { InputLabel } from "../../library-components/InputLabel";
+import { addEpsilons } from "../../bits";
+import { measureWrap } from "socket-function/src/profiling/measure";
 import { ArchiveViewerTable } from "./ArchiveViewerTable";
 import { liveWatchPaths, skipStringsURL, skipValuesURL, startTime, endTime, addFileCount, archiveFileValue, filtersURL, viewMode, archiveViewerDiskCache } from "./archiveViewerShared";
 import { ArchiveViewerFilterUI, filterDatums } from "./archiveViewerFilter";
@@ -33,6 +29,8 @@ import { t } from "../../4-querysub/Querysub";
 import { Anchor } from "../../library-components/ATag";
 import { assertIsManagementUser } from "../../diagnostics/managementPages";
 import { ButtonSelector } from "../../library-components/ButtonSelector";
+import { AuthoritySpec } from "../../0-path-value-core/PathRouter";
+import { getAllAuthoritySpec } from "../../0-path-value-core/PathRouterServerAuthoritySpec";
 
 // NOTE: We can load up to about 1M PathValues (although it really depends on their contents,
 //  specifically how many unique paths there are). After that the browser will likely stop
@@ -103,11 +101,7 @@ export class ArchiveViewer extends qreact.Component {
                 return;
             }
             try {
-                let newValuePaths = await controller.getValuePaths({
-                    //pathPrefix: getPathStr1(getDomain()),
-                    // More paths is probably better, as it might catch corrupted or missing domain files?
-                    pathPrefix: rootPathStr,
-                });
+                let newValuePaths = await controller.getValuePaths(getAllAuthoritySpec());
                 Querysub.localCommit(() => this.state.valuePaths = newValuePaths);
             } catch (e: any) {
                 Querysub.localCommit(() => {
@@ -190,8 +184,7 @@ export class ArchiveViewer extends qreact.Component {
             this.state.parsedValues = atomicObjectWrite({});
         });
 
-        // NOTE: I don't understand why we were grouping this. Doing a thousand calls is not that slow, there's not that much overhead. And we want to have small groups, that way, we get more progress. 
-        const MAX_FILES = 1;
+        const MAX_FILES = 50;
         const MAX_SIZE = 500 * 1024 * 1024;
         let bufferObjs: { path: string; buffer: Buffer }[] = [];
         let newParsedValues: { [path: string]: PathValue[] } = {};
@@ -249,14 +242,15 @@ export class ArchiveViewer extends qreact.Component {
             this.state.progress.filesParsed.max = remainingFiles.size + bufferObjs.length;
         });
 
-        await Promise.all(fileGroups.map(async group => {
-            //let time = Date.now();
+        for (let group of fileGroups) {
+            let time = Date.now();
+            console.log(`Downloading ${group.file.length} files, ${formatNumber(group.size)}B, at ${formatDateTime(time)}`);
             let newBuffers = await controller.getRawValueFiles(group.file, {
                 // 1) Allows viewing old archives
                 // 2) Allows viewing data that is being updated frequently more easily?
                 includeRecycleBin: true
             });
-            //console.log(`Downloaded ${formatNumber(newBuffers.map(x => x.length).reduce((a, b) => a + b, 0))}B in ${formatTime(Date.now() - time)}`);
+            console.log(`Downloaded ${formatNumber(newBuffers.map(x => x.length).reduce((a, b) => a + b, 0))}B in ${formatTime(Date.now() - time)}`);
             if (newBuffers.length !== group.file.length) {
                 throw new Error(`Expected ${group.file.length} buffers, got ${newBuffers.length}`);
             }
@@ -269,7 +263,7 @@ export class ArchiveViewer extends qreact.Component {
                     console.log(`Missing buffer for ${file}, skipping`);
                     continue;
                 }
-                console.log(`Downloaded ${file}, ${formatNumber(buffer.length)}B`);
+                //console.log(`Downloaded ${file}, ${formatNumber(buffer.length)}B`);
                 archiveViewerDiskCache().set(file, buffer);
                 bufferObjs.push({ path: file, buffer });
             }
@@ -277,7 +271,7 @@ export class ArchiveViewer extends qreact.Component {
                 this.state.progress.filesDownloaded.value += group.file.length;
                 this.state.progress.bytesDownloaded += newBuffers.reduce((sum, buffer) => sum + (buffer?.buffer.byteLength || 0), 0);
             });
-        }));
+        }
         Querysub.commitLocal(() => {
             this.state.progress.filesDownloaded.endTime = Date.now();
         });
@@ -720,7 +714,7 @@ class ProcessProgress extends qreact.Component<{
 
 const EMPTY_BUFFER = Buffer.alloc(0);
 class ArchiveViewerControllerBase {
-    public async getValuePaths(authority: AuthorityPath): Promise<string[]> {
+    public async getValuePaths(authority: AuthoritySpec): Promise<string[]> {
         return pathValueArchives.getValuePaths(authority);
     }
     public async getValuePathSizes(files: string[]): Promise<number[]> {

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

@@ -17,7 +17,7 @@ import { pathValueSerializer } from "../../-h-path-value-serialize/PathValueSeri
 import { getSingleSizeEstimate } from "../../5-diagnostics/shared";
 import { ButtonSelector } from "../../library-components/ButtonSelector";
 
-const archiveTreeScale = createURLSync("archiveTreeScale", "size" as "count" | "equal" | "size");
+const archiveTreeScale = createURLSync("archiveTreeScale", "count" as "count" | "equal" | "size");
 const archiveTreeSelected = createURLSync("archiveTreeSelected", "");
 const archiveMinPx = createURLSync("archiveMinPx", 50);
 const forceWildcard = createURLSync("forceWildcard", "");
@@ -82,9 +82,6 @@ export class ArchiveViewerTree extends qreact.Component<{
                 if (scaleType === "size") {
                     total = node.totalSizeEstimate;
                 }
-                if (node.values.length === 1 && total > 1000 * 1000 * 1000) {
-                    debugger;
-                }
                 countInfo += `(${formatNumber(node.values.length)} /// ${sumFormatter(total)}) `;
             } else {
                 countInfo += `(${formatNumber(node.values.length)}) `;
@@ -423,6 +420,11 @@ export class ArchiveViewerTree extends qreact.Component<{
                     <ATag values={[{ param: viewMode, value: "table" }, { param: filtersURL, value: exactFilter }]}>
                         View Exact Path
                     </ATag>
+                    <Button onClick={() => {
+                        void navigator.clipboard.writeText(archiveTreeSelected.value);
+                    }}>
+                        Copy To Clipboard
+                    </Button>
                     {lastFocused && !lite && <ATag values={[{ param: viewMode, value: "inspect" }, getSetArchiveSelected(lastFocused)]}>
                         Inspect Latest
                     </ATag>}

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

@@ -1,6 +1,6 @@
 import { ExternalRenderClass, qreact } from "../../4-dom/qreact";
 import { throttleRerender } from "../../functional/throttleRerender";
-import { pathWatcher } from "../../0-path-value-core/pathValueCore";
+import { pathWatcher } from "../../0-path-value-core/PathWatcher";
 import { css } from "../../4-dom/css";
 import { TimeRangeView } from "./TimeRangeView";
 import { URLParam } from "../../library-components/URLParam";
@@ -13,7 +13,7 @@ import { managementPageURL, showingManagementURL } from "../../diagnostics/manag
 import { watchShowLocalPaths, watchValueType } from "./LocalWatchViewer";
 import { filtersURL, viewMode } from "./archiveViewerShared";
 import { proxyWatcher } from "../../2-proxy/PathValueProxyWatcher";
-import { LOCAL_DOMAIN_PATH } from "../../0-path-value-core/NodePathAuthorities";
+import { LOCAL_DOMAIN_PATH } from "../../0-path-value-core/PathRouter";
 
 const historySecondsURL = new URLParam("historySeconds", 10);
 

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

@@ -1,12 +1,12 @@
-import { PathValue, ReadLock, authorityStorage, epochTime, pathValueArchives, pathWatcher } from "../../0-path-value-core/pathValueCore";
-import { PathValueProxyWatcher, doAtomicWrites, proxyWatcher } from "../../2-proxy/PathValueProxyWatcher";
+import { PathValue, ReadLock, authorityStorage, epochTime } from "../../0-path-value-core/pathValueCore";
+import { pathWatcher } from "../../0-path-value-core/PathWatcher";
+import { PathValueProxyWatcher, proxyWatcher } from "../../2-proxy/PathValueProxyWatcher";
 import { ExternalRenderClass, qreact } from "../../4-dom/qreact";
-import { Querysub } from "../../4-querysub/Querysub";
 import { Table } from "../../5-diagnostics/Table";
 import { appendToPathStr, getPathFromStr, getPathStr } from "../../path";
 import { css } from "typesafecss";
 import { filtersURL, formatPath, viewMode } from "./archiveViewerShared";
-import { nextId, sort } from "socket-function/src/misc";
+import { nextId } from "socket-function/src/misc";
 import { ArchiveViewerFilterUI, filterDatums } from "./archiveViewerFilter";
 import { ArchiveViewerTree } from "./ArchiveViewerTree";
 import { Button } from "../../library-components/Button";
@@ -15,12 +15,10 @@ import { Anchor } from "../../library-components/ATag";
 import { ButtonSelector } from "../../library-components/ButtonSelector";
 import { throttleRerender } from "../../functional/throttleRerender";
 import { InputLabel, InputLabelURL } from "../../library-components/InputLabel";
-import { formatPercent, formatTime } from "socket-function/src/formatting/format";
-import { LOCAL_DOMAIN_PATH } from "../../0-path-value-core/NodePathAuthorities";
-import { TimeRange, TimeRangeView, getTimeRangeStats, getUniqueTimeByPath, normalizeTimeRanges } from "./TimeRangeView";
-import { ComponentSyncStatsBase } from "./ComponentSyncStats";
+import { formatTime } from "socket-function/src/formatting/format";
+import { TimeRange, TimeRangeView, getUniqueTimeByPath, normalizeTimeRanges } from "./TimeRangeView";
 import { addEpsilons } from "../../bits";
-import { pathValueSerializer } from "../../-h-path-value-serialize/PathValueSerializer";
+import { LOCAL_DOMAIN_PATH } from "../../0-path-value-core/PathRouter";
 
 export const watchValueType = new URLParam("valueType", "watch" as "watch" | "component");
 export const watchShowLocalPaths = new URLParam("showLocalPaths", false);

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

@@ -3,11 +3,10 @@ module.allowclient = true;
 import { ArchiveSnapshotOverview, ArchiveSnapshotRead, getSnapshot, getSnapshotList, loadSnapshot, saveSnapshot } from "../../0-path-value-core/archiveLocks/archiveSnapshots";
 import { qreact } from "../../4-dom/qreact";
 import { SocketFunction } from "socket-function/SocketFunction";
-import { ValueAuditController } from "../../5-diagnostics/memoryValueAudit";
 import { getBrowserUrlNode } from "../../-f-node-discovery/NodeDiscovery";
 import { Table } from "../../5-diagnostics/Table";
 import { css } from "typesafecss";
-import { t } from "../../4-querysub/Querysub";
+import { Querysub, t } from "../../4-querysub/Querysub";
 import { ATag, Anchor } from "../../library-components/ATag";
 import { URLParam } from "../../library-components/URLParam";
 import { formatDateTime, formatNumber } from "socket-function/src/formatting/format";
@@ -29,7 +28,8 @@ const selectedSnapshot = new URLParam("selectedSnapshot", "");
 export class SnapshotViewer extends qreact.Component {
     state = t.state({
         // file => true
-        expanded: t.lookup(t.boolean)
+        expanded: t.lookup(t.boolean),
+        saving: t.boolean(false),
     });
     render() {
         let controller = SnapshotViewerSynced(getBrowserUrlNode());
@@ -39,7 +39,7 @@ export class SnapshotViewer extends qreact.Component {
         if (!file || typeof file !== "string") {
             return (
                 <div class={css.pad2(10).vbox(10)}>
-                    <h1>Snapshots are taken after every change (with the new data).</h1>
+                    <h1>Snapshots are taken before every change. "zombie" means the file exists, but it has no confirm (so it will be ignored).</h1>
                     <Table
                         rows={snapshotList}
                         columns={{
@@ -56,10 +56,16 @@ export class SnapshotViewer extends qreact.Component {
                                         </ATag>
                                         {context?.row?.file === "live" &&
                                             <Button onClick={async () => {
-                                                await SnapshotViewerController.nodes[getBrowserUrlNode()].saveLiveSnapshot();
-                                                console.log("Saved live snapshot.");
+                                                this.state.saving = true;
+                                                try {
+                                                    await SnapshotViewerSynced(getBrowserUrlNode()).saveLiveSnapshot.promise();
+                                                } finally {
+                                                    Querysub.localCommit(() => {
+                                                        this.state.saving = false;
+                                                    });
+                                                }
                                             }}>
-                                                Save
+                                                {this.state.saving ? "Saving..." : "Save"}
                                             </Button>
                                         }
                                     </div>;
@@ -155,9 +161,9 @@ async function seriousConfirm(config: {
                     </pre>}
                     onChangeValue={value => {
                         if (value === "confirm") {
-                            modal.close();
                             resolve(true);
                         }
+                        modal.close();
                     }}
                 />
             </FullscreenModal>
@@ -175,9 +181,6 @@ class SnapshotViewerControllerBase {
     }): Promise<void> {
         await loadSnapshot({
             overview: config.overview,
-            async audit(nodeId) {
-                await ValueAuditController.nodes[nodeId].diskAuditNow();
-            },
         });
     }
 
@@ -207,4 +210,12 @@ export const SnapshotViewerController = SocketFunction.register(
         noAutoExpose: true,
     }
 );
-const SnapshotViewerSynced = getSyncedController(SnapshotViewerController);
+const SnapshotViewerSynced = getSyncedController(SnapshotViewerController, {
+    reads: {
+        getSnapshotList: ["snapshots"],
+        getSnapshot: ["snapshots"],
+    },
+    writes: {
+        saveLiveSnapshot: ["snapshots"],
+    }
+});

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

@@ -12,7 +12,7 @@ import { css } from "typesafecss";
 
 export const startTime = createURLSync("archiveStartTime", 0);
 export const endTime = createURLSync("archiveEndTime", +new Date("2100/01/01 00:00:00"));
-export const archiveFileValue = createURLSync("archiveFileValue", "files" as "files" | "datums" | "bytes");
+export const archiveFileValue = createURLSync("archiveFileValue", "datums" as "files" | "datums" | "bytes");
 export const filtersURL = createURLSync("archivefilters2", {} as { [key: string]: FilterPart });
 
 export const liveWatchPaths = createURLSync("liveWatchPaths", {} as { [path: string]: true });