querysub 0.518.0 → 0.520.0

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

@@ -0,0 +1,324 @@
+module.allowclient = true;
+
+import { qreact } from "../../4-dom/qreact";
+import { css } from "typesafecss";
+import { SocketFunction } from "socket-function/SocketFunction";
+import { getAllNodeIds, getBrowserUrlNode } from "../../-f-node-discovery/NodeDiscovery";
+import { LatencyController } from "../../-f-node-discovery/LatencyTracking";
+import { TrafficController, TrafficStats } from "../../-f-node-discovery/TrafficTracking";
+import { getDomain } from "../../config";
+import { decodeNodeId } from "sliftutils/misc/https/certs";
+import { getSyncedController } from "../../library-components/SyncedController";
+import { assertIsManagementUser } from "../managementPages";
+import { NodeCapabilitiesController } from "../../-g-core-values/NodeCapabilities";
+import { timeoutToUndefinedSilent } from "../../errors";
+import { sort } from "socket-function/src/misc";
+import type { AuthoritySpec } from "../../0-path-value-core/PathRouter";
+import { getFunctionRunnerIndex, FunctionRunnerNodeInfo } from "../../4-querysub/FunctionRunnerTracking";
+import { formatTime, formatNumber } from "socket-function/src/formatting/format";
+import { LatencyGraph, LatencyGraphNode, LatencyGraphLink, LatencyGraphLabelLine } from "../../library-components/LatencyGraph";
+
+const ID_CHARS = 8;
+// Green means querysub, blue means path value, purple means function runner.
+const FUNCTION_COLOR = "hsl(280, 65%, 72%)";
+const PATHVALUE_COLOR = "hsl(210, 75%, 68%)";
+const QUERYSUB_COLOR = "hsl(140, 60%, 60%)";
+
+const PROBE_TIMEOUT_MS = 5000;
+const RANGE_BAR_WIDTH_PX = 360;
+const RANGE_BAR_HEIGHT_PX = 14;
+const LATENCY_GRAPH_HEIGHT_PX = 720;
+
+type NodeAuthorityInfo = {
+    nodeId: string;
+    entryPoint?: string;
+    spec?: AuthoritySpec;
+};
+
+class RoutingTablePageControllerBase {
+    public async getAllNodeAuthoritySpecs(): Promise<NodeAuthorityInfo[]> {
+        let nodes = await getAllNodeIds();
+        return Promise.all(nodes.map(async (nodeId): Promise<NodeAuthorityInfo> => {
+            let metadata = await timeoutToUndefinedSilent(PROBE_TIMEOUT_MS, NodeCapabilitiesController.nodes[nodeId].getMetadata());
+            return { nodeId, entryPoint: metadata?.entryPoint, spec: metadata?.authoritySpec };
+        }));
+    }
+    // Proxies a single node's own latency map (browser can't talk to nodes directly). One call per node, so the
+    // graph can render each node's latencies as they arrive, and just skip nodes that are slow or unreachable.
+    public async getNodeLatencies(nodeId: string): Promise<{ [nodeId: string]: number } | undefined> {
+        return timeoutToUndefinedSilent(PROBE_TIMEOUT_MS, LatencyController.nodes[nodeId].getLatencies());
+    }
+    // Renamed (was getNodeTraffic) because the returned shape changed — a new name busts any stale synced-call cache.
+    public async getNodeTrafficStats(nodeId: string): Promise<TrafficStats | undefined> {
+        return timeoutToUndefinedSilent(PROBE_TIMEOUT_MS, TrafficController.nodes[nodeId].getTrafficStats());
+    }
+}
+
+export const RoutingTablePageController = SocketFunction.register(
+    "AuthoritySpecPageController-7b8c9d0e-1f2a-3b4c-5d6e-7f8090a1b2c3",
+    new RoutingTablePageControllerBase(),
+    () => ({
+        getAllNodeAuthoritySpecs: {},
+        getNodeLatencies: {},
+        getNodeTrafficStats: {},
+    }),
+    () => ({
+        hooks: [assertIsManagementUser],
+    }),
+    {
+        noAutoExpose: true,
+    }
+);
+
+const RoutingTableSynced = getSyncedController(RoutingTablePageController, {
+    reads: { getAllNodeAuthoritySpecs: ["nodeAuthoritySpecs"] },
+    writes: {},
+});
+
+class AuthorityRangeBar extends qreact.Component<{ start: number; end: number }> {
+    render() {
+        let startPct = this.props.start * 100;
+        let widthPct = (this.props.end - this.props.start) * 100;
+        return <div className={css.relative.size(RANGE_BAR_WIDTH_PX, RANGE_BAR_HEIGHT_PX).flexShrink0.hsl(0, 0, 92).bord2(0, 0, 75)}>
+            <div className={css.absolute.top(0).left(`${startPct}%`).size(`${widthPct}%`, "100%").hsl(210, 65, 50)} />
+        </div>;
+    }
+}
+
+class AuthorityNodeRow extends qreact.Component<{ info: NodeAuthorityInfo }> {
+    state = {
+        expanded: false,
+    };
+    render() {
+        let info = this.props.info;
+        let spec = info.spec!;
+        let expanded = this.state.expanded;
+        return <div
+            className={css.button.vbox(6).pad2(10).fillWidth.bord2(0, 0, 85).hsl(0, 0, 99)}
+            onClick={() => this.state.expanded = !expanded}
+        >
+            <div className={css.hbox(10).fillWidth}>
+                <span>{expanded ? "▼" : "▶"}</span>
+                <span className={css.boldStyle}>{info.nodeId}</span>
+                <span>{spec.routeStart.toFixed(4)} - {spec.routeEnd.toFixed(4)}</span>
+                <AuthorityRangeBar start={spec.routeStart} end={spec.routeEnd} />
+                <span className={css.colorhsl(0, 0, 50)}>width {(spec.routeEnd - spec.routeStart).toFixed(4)}</span>
+                {spec.excludeDefault && <span className={css.colorhsl(0, 70, 35)}>(excludes default)</span>}
+                <span className={css.colorhsl(0, 0, 40).ellipsis.flexFillWidth}>{info.entryPoint || "(no entry point)"}</span>
+            </div>
+            {expanded &&
+                <div className={css.vbox(2)}>
+                    <div className={css.boldStyle}>Prefixes ({spec.prefixes.length}):</div>
+                    {spec.prefixes.length === 0 && <div className={css.colorhsl(0, 0, 50)}>(none)</div>}
+                    {spec.prefixes.map(p =>
+                        <div key={p.originalPrefix} className={css.colorhsl(0, 0, 25)}>{p.originalPrefix}</div>
+                    )}
+                </div>
+            }
+        </div>;
+    }
+}
+
+class FunctionRunnersSection extends qreact.Component {
+    render() {
+        let index = getFunctionRunnerIndex();
+        let nodes = index?.nodes || [];
+        return <div className={css.vbox(8).fillWidth}>
+            <h2>Function Runners ({nodes.length})</h2>
+            {nodes.length === 0 && <div className={css.colorhsl(0, 0, 50)}>(no function runners found yet)</div>}
+            {nodes.map(node =>
+                <div className={css.vbox(4).pad2(10).fillWidth.bord2(0, 0, 85).hsl(0, 0, 99)}>
+                    <div className={css.hbox(10).fillWidth}>
+                        <span className={css.boldStyle}>{node.nodeId}</span>
+                        <span className={css.colorhsl(210, 60, 40)}>networks: {node.networks.join(", ")}</span>
+                        {!node.isPublic && <span className={css.colorhsl(0, 70, 35)}>(non-public)</span>}
+                        <span>latency {formatTime(node.averageLatency)}</span>
+                        <span>up for {formatTime(Date.now() - node.startupTime)}</span>
+                        <span className={css.colorhsl(0, 0, 40).ellipsis}>{node.entryPoint}</span>
+                    </div>
+                    {node.shards.map(shard =>
+                        <div className={css.hbox(10).fillWidth}>
+                            <span>{shard.shardRange.startFraction.toFixed(4)} - {shard.shardRange.endFraction.toFixed(4)}</span>
+                            <AuthorityRangeBar start={shard.shardRange.startFraction} end={shard.shardRange.endFraction} />
+                            {shard.secondaryShardRange && <span className={css.colorhsl(0, 0, 50)}>secondary {shard.secondaryShardRange.startFraction.toFixed(4)} - {shard.secondaryShardRange.endFraction.toFixed(4)}</span>}
+                        </div>
+                    )}
+                </div>
+            )}
+        </div>;
+    }
+}
+
+function nodeLabelLines(config: {
+    nodeId: string;
+    runner: FunctionRunnerNodeInfo | undefined;
+    info: NodeAuthorityInfo | undefined;
+    traffic: TrafficStats | undefined;
+}): LatencyGraphLabelLine[] {
+    let { nodeId, runner, info, traffic } = config;
+    let parts = decodeNodeId(nodeId, getDomain(), "allowMissingThreadId");
+    let thread = (parts?.threadId || "?").slice(0, ID_CHARS);
+    let machine = (parts?.machineId || nodeId).slice(0, ID_CHARS);
+    let lines: LatencyGraphLabelLine[] = [{ text: `${thread}:${parts?.port ?? "?"}` }];
+    // The last segment of the entry-point path is a good human name; shown on one line with the server (machine) id.
+    let entryPoint = info?.entryPoint || runner?.entryPoint;
+    let name = entryPoint ? entryPoint.split(/[\\/]/).filter(Boolean).at(-1) : undefined;
+    lines.push({ text: name ? `${name}  ${machine}` : machine });
+    // Total data this node sent / received, and the percent of it that went outside our known node list.
+    if (traffic) {
+        let totals = nodeTotalTraffic(traffic);
+        let sum = totals.sent + totals.received;
+        if (sum > 0) {
+            let outsidePct = Math.round((totals.outside / sum) * 100);
+            lines.push({ text: `↑${formatNumber(totals.sent)}B ↓${formatNumber(totals.received)}B ${outsidePct}%⊘` });
+        }
+    }
+    // All function-runner info on one purple line: networks, shard ranges, calls, private.
+    if (runner) {
+        let fnParts: string[] = [];
+        if (runner.networks.length) fnParts.push(runner.networks.join(" "));
+        for (let shard of runner.shards) {
+            fnParts.push(`fn ${shard.shardRange.startFraction.toFixed(3)}-${shard.shardRange.endFraction.toFixed(3)}`);
+        }
+        fnParts.push(`${formatNumber(traffic?.functionsExecuted ?? 0)} calls`);
+        if (!runner.isPublic) fnParts.push("PRIVATE");
+        lines.push({ text: fnParts.join("  "), color: FUNCTION_COLOR });
+    }
+    // All path-value info on one blue line: shard range (only if real) and values sent.
+    let spec = info?.spec;
+    let pvParts: string[] = [];
+    if (spec && spec.routeStart >= 0 && spec.routeEnd >= 0) {
+        pvParts.push(`pv ${spec.routeStart.toFixed(3)}-${spec.routeEnd.toFixed(3)}`);
+    }
+    if (traffic && (traffic.pathValuesSent || traffic.pathValuesReceived)) {
+        pvParts.push(`↑${formatNumber(traffic.pathValuesSent)} ↓${formatNumber(traffic.pathValuesReceived)} values`);
+    }
+    if (pvParts.length) {
+        lines.push({ text: pvParts.join("  "), color: PATHVALUE_COLOR });
+    }
+    // Querysub activity: how many function calls were submitted to this node's QuerysubController.
+    if (traffic?.querysubCalls) {
+        lines.push({ text: `${formatNumber(traffic.querysubCalls)} addCalls`, color: QUERYSUB_COLOR });
+    }
+    return lines;
+}
+
+function nodeTotalTraffic(traffic: TrafficStats): { sent: number; received: number; outside: number; } {
+    let sent = traffic.outside.sent;
+    let received = traffic.outside.received;
+    for (let d of Object.values(traffic.perNode)) {
+        sent += d.sent;
+        received += d.received;
+    }
+    return { sent, received, outside: traffic.outside.sent + traffic.outside.received };
+}
+
+class LatencyGraphSection extends qreact.Component<{ nodeIds: string[]; infos: NodeAuthorityInfo[] }> {
+    render() {
+        let nodeIds = this.props.nodeIds;
+        let synced = RoutingTableSynced(getBrowserUrlNode());
+
+        let index = getFunctionRunnerIndex();
+        let runnerByNode = new Map<string, FunctionRunnerNodeInfo>();
+        for (let node of index?.nodes ?? []) {
+            runnerByNode.set(node.nodeId, node);
+        }
+        let infoByNode = new Map(this.props.infos.map(info => [info.nodeId, info]));
+
+        // One synced call per node for each data source; each resolves independently so the graph fills in progressively.
+        let latencyMaps = new Map<string, { [nodeId: string]: number }>();
+        let trafficMaps = new Map<string, TrafficStats>();
+        for (let nodeId of nodeIds) {
+            let latencies = synced.getNodeLatencies(nodeId);
+            if (latencies) latencyMaps.set(nodeId, latencies);
+            let traffic = synced.getNodeTrafficStats(nodeId);
+            if (traffic) trafficMaps.set(nodeId, traffic);
+        }
+        // Only render nodes that reported their latencies — ones that never respond probably don't exist.
+        let respondedSet = new Set(latencyMaps.keys());
+
+        // Total bytes on each node-pair link (both directions). Both endpoints report the same link total, so we take
+        // the max instead of summing. Circle size = a node's total traffic.
+        let pairKey = (a: string, b: string) => a < b ? `${a}|${b}` : `${b}|${a}`;
+        let pairTraffic = new Map<string, number>();
+        for (let [reporter, traffic] of trafficMaps) {
+            for (let [peer, data] of Object.entries(traffic.perNode)) {
+                if (reporter === peer || !respondedSet.has(peer)) continue;
+                let key = pairKey(reporter, peer);
+                pairTraffic.set(key, Math.max(pairTraffic.get(key) || 0, data.sent + data.received));
+            }
+        }
+
+        let nodes: LatencyGraphNode[] = [...respondedSet].map(nodeId => {
+            let traffic = trafficMaps.get(nodeId);
+            let totals = traffic ? nodeTotalTraffic(traffic) : undefined;
+            return {
+                id: nodeId,
+                labelLines: nodeLabelLines({ nodeId, runner: runnerByNode.get(nodeId), info: infoByNode.get(nodeId), traffic }),
+                weight: totals ? totals.sent + totals.received : 0,
+            };
+        });
+        let links: LatencyGraphLink[] = [];
+        for (let [sourceId, latencies] of latencyMaps) {
+            for (let [destId, latencyMs] of Object.entries(latencies)) {
+                if (!respondedSet.has(destId)) continue;
+                links.push({ source: sourceId, destination: destId, latencyMs, weight: pairTraffic.get(pairKey(sourceId, destId)) || 0 });
+            }
+        }
+
+        // Per-cluster summary: sum the same per-node metrics across the cluster's members.
+        let clusterSummary = (memberIds: string[]): LatencyGraphLabelLine[] => {
+            let sent = 0;
+            let received = 0;
+            let calls = 0;
+            let addCalls = 0;
+            let dataSent = 0;
+            let dataReceived = 0;
+            for (let id of memberIds) {
+                let traffic = trafficMaps.get(id);
+                if (!traffic) continue;
+                sent += traffic.pathValuesSent;
+                received += traffic.pathValuesReceived;
+                calls += traffic.functionsExecuted;
+                addCalls += traffic.querysubCalls;
+                let totals = nodeTotalTraffic(traffic);
+                dataSent += totals.sent;
+                dataReceived += totals.received;
+            }
+            let summary: LatencyGraphLabelLine[] = [];
+            summary.push({ text: `↑${formatNumber(dataSent)}B ↓${formatNumber(dataReceived)}B` });
+            summary.push({ text: `↑${formatNumber(sent)} ↓${formatNumber(received)} values`, color: PATHVALUE_COLOR });
+            summary.push({ text: `${formatNumber(calls)} calls`, color: FUNCTION_COLOR });
+            summary.push({ text: `${formatNumber(addCalls)} addCalls`, color: QUERYSUB_COLOR });
+            return summary;
+        };
+
+        return <div className={css.vbox(8).fillWidth}>
+            <h2 className={css.margin(0)}>Latency Graph ({respondedSet.size}/{nodeIds.length} nodes reported)</h2>
+            <div className={css.relative.fillWidth.height(LATENCY_GRAPH_HEIGHT_PX).bord2(0, 0, 85)}>
+                <LatencyGraph nodes={nodes} links={links} formatWeight={weight => formatNumber(weight) + "B"} clusterSummary={clusterSummary} />
+            </div>
+        </div>;
+    }
+}
+
+export class RoutingTablePage extends qreact.Component {
+    render() {
+        let infos = RoutingTableSynced(getBrowserUrlNode()).getAllNodeAuthoritySpecs();
+        if (!infos) {
+            return <div className={css.pad2(16)}>Loading routing table...</div>;
+        }
+        let allNodeIds = infos.map(x => x.nodeId);
+        let routableInfos = infos.filter(x => x.spec && x.spec.routeStart >= 0 && x.spec.routeEnd >= 0);
+        sort(routableInfos, x => x.spec!.routeStart);
+
+        return <div className={css.vbox(12).pad2(16).fillWidth}>
+            <LatencyGraphSection nodeIds={allNodeIds} infos={infos} />
+            <h2>Routing Table ({routableInfos.length})</h2>
+            <div className={css.vbox(8).fillWidth}>
+                {routableInfos.map(info => <AuthorityNodeRow key={info.nodeId} info={info} />)}
+            </div>
+            <FunctionRunnersSection />
+        </div>;
+    }
+}

package/src/diagnostics/pathAuditer.ts

@@ -308,7 +308,8 @@ async function auditAuthority(nodeId: string, pathsToAudit: { path: string }[],
     let valuesToSend: PathValue[] = [];
     let pathsToForceSync = new Set<string>();
 
-    for (let response of responses) {
+    for (let [requestIndex, response] of responses.entries()) {
+        let request = requests[requestIndex];
         let originalValue = originalValues.get(response.path);
         let ourValue = authorityStorage.getValueAtOrBeforeTime(response.path) || createMissingEpochValue(response.path);
 
@@ -328,6 +329,64 @@ async function auditAuthority(nodeId: string, pathsToAudit: { path: string }[],
 
         if (ourValue.isTransparent && response.isTransparent) continue;
 
+        if (request.time) {
+            let ourExact = authorityStorage.getValueExactMaybeRejected(request.path, request.time);
+            if (!ourExact || !ourExact.valid) continue;
+            if (compareTime(ourExact.time, epochTime) === 0) continue;
+            // The exact value = server does not have
+            //      - Send it our value
+            if (!response.time) {
+                valuesToSend.push(ourExact);
+                trackSyncAge({
+                    path: request.path,
+                    ourTimeId: ourExact.time.time,
+                    remoteTimeId: undefined,
+                    ourValid: ourExact.valid,
+                    remoteValid: response.valid,
+                    remoteNodeId: nodeId,
+                    reason: "Remote is missing our value, sending it to them",
+                });
+                continue;
+            }
+            // The exact value = server has, but says it's not valid
+            //      - If time < MAX_CHANGE_AGE old, record this, and wait until MAX_CHANGE_AGE (put it in some other kind of queue), and then check again
+            //      - If time >= MAX_CHANGE_AGE old, then tell it to change it's valid state to ours. Also, tell all other authorities that use this path.
+            // NOTE: We skew towards making values valid instead of invalid. So if there's disagreement, we always take the valid value instead of the invalid value.
+            // NOTE: The opposite case, if the remote is valid and ours is invalid, is handled by our latest value being older than the remote value, as we're never going to ask about an invalid value. It'll just implicitly change what the latest valid value is.
+            if (response.valid === false) {
+                let age = now - ourExact.time.time;
+                if (age >= MAX_CHANGE_AGE) {
+                    pathsToForceSync.add(request.path);
+                    trackSyncAge({
+                        path: request.path,
+                        ourTimeId: ourExact.time.time,
+                        remoteTimeId: response.time.time,
+                        ourValid: ourExact.valid,
+                        remoteValid: response.valid,
+                        remoteNodeId: nodeId,
+                        reason: "Remote says our value is invalid, but we think it's valid. Telling all nodes about this value to ensure it's in sync everywhere.",
+                    });
+                } else {
+                    if (!pendingValidityCheckPaths.has(request.path)) {
+                        let newCheck: PendingValidityCheck = {
+                            path: request.path,
+                            ourTimeId: ourExact.time.time,
+                            remoteTimeId: response.time.time,
+                            ourValid: ourExact.valid,
+                            remoteValid: response.valid,
+                            remoteNodeId: nodeId,
+                            discoveredAt: now,
+                        };
+                        let insertIndex = binarySearchBasic2(pendingValidityChecks, check => check.discoveredAt, newCheck);
+                        if (insertIndex < 0) insertIndex = ~insertIndex;
+                        pendingValidityChecks.splice(insertIndex, 0, newCheck);
+                        pendingValidityCheckPaths.add(request.path);
+                    }
+                }
+            }
+            continue;
+        }
+
         // it's latest valid is newer than ours
         //      - Ask it for the value of the latest
         if (response.valid && response.time && compareTime(response.time, ourValue.time) > 0) {
@@ -357,42 +416,6 @@ async function auditAuthority(nodeId: string, pathsToAudit: { path: string }[],
                 reason: "Remote is missing our value, sending it to them",
             });
         }
-        // Our latest valid = server has, but says it's not valid
-        //      - If time < MAX_CHANGE_AGE old, record this, and wait until MAX_CHANGE_AGE (put it in some other kind of queue), and then check again
-        //      - If time >= MAX_CHANGE_AGE old, then tell it to change it's valid state to ours. Also, tell all other authorities that use this path.
-        // NOTE: We skew towards making values valid instead of invalid. So if there's disagreement, we always take the valid value instead of the invalid value.
-        // NOTE: The opposite case, if the remote is valid and ours is invalid, is handled by our latest value being older than the remote value, as we're never going to ask about an invalid value. It'll just implicitly change what the latest valid value is. 
-        else if (!response.valid && ourValue.valid && ourValue.time !== epochTime) {
-            let age = now - ourValue.time.time;
-            if (age >= MAX_CHANGE_AGE) {
-                pathsToForceSync.add(response.path);
-                trackSyncAge({
-                    path: response.path,
-                    ourTimeId: ourValue.time.time,
-                    remoteTimeId: response.time?.time,
-                    ourValid: ourValue.valid,
-                    remoteValid: response.valid,
-                    remoteNodeId: nodeId,
-                    reason: "Remote says our value is invalid, but we think it's valid. Telling all nodes about this value to ensure it's in sync everywhere.",
-                });
-            } else {
-                if (!pendingValidityCheckPaths.has(response.path)) {
-                    let newCheck: PendingValidityCheck = {
-                        path: response.path,
-                        ourTimeId: ourValue.time.time,
-                        remoteTimeId: response.time?.time,
-                        ourValid: ourValue.valid ?? false,
-                        remoteValid: response.valid,
-                        remoteNodeId: nodeId,
-                        discoveredAt: now,
-                    };
-                    let insertIndex = binarySearchBasic2(pendingValidityChecks, check => check.discoveredAt, newCheck);
-                    if (insertIndex < 0) insertIndex = ~insertIndex;
-                    pendingValidityChecks.splice(insertIndex, 0, newCheck);
-                    pendingValidityCheckPaths.add(response.path);
-                }
-            }
-        }
     }
 
     if (valuesToRequest.length > 0) {
@@ -404,6 +427,7 @@ async function auditAuthority(nodeId: string, pathsToAudit: { path: string }[],
                     pathValues: receivedValues,
                     parentSyncs: [],
                     initialTriggers: { values: new Set(), parentPaths: new Set() },
+                    doNotArchive: true,
                 });
             }
         }
@@ -447,7 +471,12 @@ class PathAuditerService {
     public async getValidStates(requests: PathTimeRequest[]): Promise<ValidStateResponse[]> {
         let results: ValidStateResponse[] = [];
         for (let request of requests) {
-            let value = authorityStorage.getValueAtOrBeforeTime(request.path, request.time);
+            let value: PathValue | undefined;
+            if (request.time) {
+                value = authorityStorage.getValueExactMaybeRejected(request.path, request.time);
+            } else {
+                value = authorityStorage.getValueAtOrBeforeTime(request.path);
+            }
             results.push({
                 path: request.path,
                 time: value?.time,
@@ -462,8 +491,13 @@ class PathAuditerService {
     public async getPathValues(requests: PathTimeRequest[]): Promise<Buffer[]> {
         let results: PathValue[] = [];
         for (let request of requests) {
-            let value = authorityStorage.getValueAtOrBeforeTime(request.path, request.time);
-            if (value) {
+            let value: PathValue | undefined;
+            if (request.time) {
+                value = authorityStorage.getValueExactMaybeRejected(request.path, request.time);
+            } else {
+                value = authorityStorage.getValueAtOrBeforeTime(request.path);
+            }
+            if (value && value.valid) {
                 results.push(value);
             }
         }
@@ -477,6 +511,7 @@ class PathAuditerService {
             pathValues: values,
             parentSyncs: [],
             initialTriggers: { values: new Set(), parentPaths: new Set() },
+            doNotArchive: true,
         });
     }