querysub 0.407.0 → 0.409.0

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

@@ -177,6 +177,7 @@ class PathValueCommitter {
                     auditLog("CREATE VALUE", {
                         path: pathValue.path,
                         timeId: pathValue.time.time,
+                        timeIdFull: pathValue.time,
                         source: pathValue.source,
                         transparent: pathValue.isTransparent,
                         // value: valueStr,
@@ -242,7 +243,7 @@ class PathValueCommitter {
                 void forwardPromise.then(x => {
                     if (x === "refused") {
                         values = values.map(value => {
-                            console.info(`Rejecting past value due to initial sync: ${debugPathValuePath(value)}`, {
+                            console.info(`Rejecting value that was refused: ${debugPathValuePath(value)}`, {
                                 path: value.path,
                                 timeId: value.time.time,
                             });
@@ -312,6 +313,7 @@ class PathValueCommitter {
                                     let candidates = PathRouter.getAllAuthorities(path);
                                     require("debugbreak")(2);
                                     debugger;
+                                    remoteWatcher.getExistingWatchRemoteNodeId(path);
                                     console.warn(`Ignoring value from wrong authority. Should have been ${debugNodeId(watchingAuthorityId)}, but was received from ${debugNodeId(batch.sourceNodeId)}.`, {
                                         path,
                                         type,

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

@@ -7,7 +7,6 @@ import { ActionsHistory } from "../diagnostics/ActionsHistory";
 import { isNode, nextId, timeInSecond, timeoutToUndefined } from "socket-function/src/misc";
 import { pathValueSerializer } from "../-h-path-value-serialize/PathValueSerializer";
 import { pathValueCommitter } from "./PathValueCommitter";
-import { Benchmark } from "../diagnostics/benchmark";
 import { auditLog, isDebugLogEnabled } from "./auditLogs";
 import { debugNodeId, debugNodeThread } from "../-c-identity/IdentityController";
 import { isDiskAudit } from "../config";
@@ -17,8 +16,18 @@ import { getNodeIdIP } from "socket-function/src/nodeCache";
 import { authorityLookup } from "./AuthorityLookup";
 import { timeoutToError } from "../errors";
 import { AuthoritySpec, PathRouter } from "./PathRouter";
+import { LZ4 } from "../storage/LZ4";
+import { Time } from "./pathValueCore";
+import { encodeCborx, decodeCborx } from "../misc/cloneHelpers";
+import { debugGetAllCallFactories } from "socket-function/src/nodeCache";
 export { pathValueCommitter };
 
+// ONLY returns non-canGCValues that are valid
+export type AuditSnapshotEntry = {
+    path: string;
+    time: Time;
+};
+
 // The sync test page has some functions which related to PathValueController significantly, and should always be exposed if PathValueController is exposed.
 if (isNode()) {
     setImmediate(() => {
@@ -43,6 +52,7 @@ export class PathValueControllerBase {
                 auditLog("SEND CREATED VALUE", {
                     path: value.path,
                     timeId: value.time.time,
+                    timeIdVersion: value.time.version,
                     targetNodeThreadId: debugNodeThread(nodeId),
                     transparent: value.isTransparent,
                     source: value.source,
@@ -66,6 +76,7 @@ export class PathValueControllerBase {
                 auditLog("SEND VALUE", {
                     path: pathValue.path,
                     timeId: pathValue.time.time,
+                    timeIdVersion: pathValue.time.version,
                     watcher: nodeId,
                     isValid: pathValue.valid,
                     nodeId: debugNodeId(nodeId),
@@ -119,7 +130,6 @@ export class PathValueControllerBase {
         let values: PathValue[] = [];
         if (valueBuffers) {
             values = await pathValueSerializer.deserialize(valueBuffers);
-            Benchmark.onReceivedValues(values);
             ActionsHistory.OnRead(values);
         }
 
@@ -152,6 +162,7 @@ export class PathValueControllerBase {
                     path: value.path,
                     // NOTE: Yes, this might conflict as we're throwing away a lot of information, however in practice no, it's not going to conflict when we're debugging, and this + path will be globally unique for every value we investigate.
                     timeId: value.time.time,
+                    timeIdVersion: value.time.version,
                     sourceNodeId,
                     sourceNodeThreadId: decodeNodeId(sourceNodeId)?.threadId,
                 });
@@ -252,6 +263,65 @@ export class PathValueControllerBase {
         });
         return buffers;
     }
+
+    public static async getAuditSnapshot(config: {
+        nodeId: string;
+        spec: AuthoritySpec;
+    }): Promise<AuditSnapshotEntry[]> {
+        let compressed = await PathValueController.nodes[config.nodeId].getAuditSnapshot(config);
+        let decompressed = LZ4.decompress(compressed);
+        return decodeCborx(decompressed);
+    }
+
+    public async getAuditSnapshot(config: {
+        spec: AuthoritySpec;
+    }): Promise<Buffer> {
+        let { spec } = config;
+        let { compareTime } = await import("./pathValueCore");
+
+        let allValues = authorityStorage.getAllValues({ spec, startTime: 0, endTime: Number.MAX_SAFE_INTEGER });
+
+        let pathToLatest = new Map<string, Time>();
+        for (let value of allValues) {
+            if (!value.valid) continue;
+            if (value.canGCValue) continue;
+
+            let existing = pathToLatest.get(value.path);
+            if (!existing || compareTime(value.time, existing) > 0) {
+                pathToLatest.set(value.path, value.time);
+            }
+        }
+
+        let entries: AuditSnapshotEntry[] = Array.from(pathToLatest.entries()).map(([path, time]) => ({ path, time }));
+
+        let encoded = encodeCborx(entries);
+        return LZ4.compress(encoded);
+    }
+
+
+    public static async getValuesByPathAndTime(config: {
+        nodeId: string;
+        entries: AuditSnapshotEntry[];
+    }): Promise<PathValue[]> {
+        let buffers = await PathValueController.nodes[config.nodeId].getValuesByPathAndTime(config.entries);
+        return await pathValueSerializer.deserialize(buffers);
+    }
+
+    public async getValuesByPathAndTime(entries: AuditSnapshotEntry[]): Promise<Buffer[]> {
+        let values: PathValue[] = [];
+        for (let entry of entries) {
+            let value = authorityStorage.getValueExactIgnoreInvalid(entry.path, entry.time);
+            if (!value) continue;
+            if (value.isTransparent) continue;
+            if (value.canGCValue) continue;
+            values.push(value);
+        }
+        let buffers = await pathValueSerializer.serialize(values, {
+            noLocks: true,
+            compress: getCompressNetwork(),
+        });
+        return buffers;
+    }
 }
 
 export const PathValueController = SocketFunction.register(
@@ -261,6 +331,8 @@ export const PathValueController = SocketFunction.register(
         sendData: {},
 
         getInitialValues: {},
+        getAuditSnapshot: {},
+        getValuesByPathAndTime: {},
 
         watchLatest: {},
         unwatchLatest: {},
@@ -271,5 +343,4 @@ export const PathValueController = SocketFunction.register(
     {
         noFunctionMeasure: !isNode(),
     }
-);
-
+);

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

@@ -12,13 +12,43 @@ import { PathRouter } from "./PathRouter";
 import { auditLog } from "./auditLogs";
 import { WatchConfig, authorityStorage, PathValue, NodeId, compareTime, isCoreQuiet, MAX_CHANGE_AGE, createMissingEpochValue } from "./pathValueCore";
 import { matchesParentRangeFilter } from "./hackedPackedPathParentFiltering";
+import { isClient } from "../config2";
+import { delay } from "socket-function/src/batching";
 
+setImmediate(() => import("../4-querysub/Querysub"));
 
 // These are used so we can have our internal trigger lookup without watching them on remote values. 
 export function getInternalValueWatchPrefix() {
     return "INTERNAL_VALUE_WATCH_PREFIX_";
 }
 
+let pathWatcherState: (() => { watcherSequence: number }) | undefined;
+
+setImmediate(async () => {
+    const { createLocalSchema } = await import("../4-querysub/schemaHelpers");
+    const { t } = await import("../2-proxy/schema2");
+    pathWatcherState = createLocalSchema("pathWatcherState", {
+        watcherSequence: t.number
+    });
+});
+
+let triggering = false;
+function incrementWatcherSequence() {
+    if (!isClient()) return;
+    if (!pathWatcherState) return;
+    if (triggering) return;
+    triggering = true;
+    void delay(10).finally(async () => {
+        let { Querysub } = await import("../4-querysub/Querysub");
+        triggering = false;
+        Querysub.commit(() => {
+            if (!pathWatcherState) return;
+            let state = pathWatcherState();
+            state.watcherSequence = (state.watcherSequence || 0) + 1;
+        });
+    });
+}
+
 // WATCH CASES
 // 1) getOwnNodeId() is used to trigger pathValueClientWatcher (no one else should be using it)
 // 2) Use other nodes to immediately proxy to the other nodes
@@ -133,6 +163,7 @@ class PathWatcher {
         }
 
         if (newPathsWatched.size > 0 || newParentsWatched.size > 0) {
+            incrementWatcherSequence();
             if (isOwnNodeId(config.nodeId)) {
                 for (let path of newPathsWatched) {
                     auditLog("new local WATCH VALUE", { path });
@@ -269,6 +300,7 @@ class PathWatcher {
         }
 
         if (fullyUnwatched.paths.length > 0 || fullyUnwatched.parentPaths.length > 0) {
+            incrementWatcherSequence();
             console.info(`Unwatched PathValue watches`, {
                 unwatchedPaths: fullyUnwatched.paths.length,
                 unwatchedParents: fullyUnwatched.parentPaths.length,
@@ -505,6 +537,13 @@ class PathWatcher {
         return Array.from(this.parentWatchers.keys());
     }
 
+    public getAllWatchedPaths(): string[] {
+        if (pathWatcherState) {
+            pathWatcherState().watcherSequence;
+        }
+        return Array.from(this.watchers.keys());
+    }
+
     public debug_harvestSyncTimes(): { start: number; end: number; path: string; }[] {
         let times = this.syncHistoryForHarvest.getAllUnordered();
         this.syncHistoryForHarvest.reset();

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

@@ -9,6 +9,7 @@
     After a PathServerValue starts, it can't change its prefixes, as if the routing changes it makes it too difficult for clients to reason about who they should be synchronizing with.
 */
 
+import { isNode } from "typesafecss";
 import { nestArchives } from "../-a-archives/archives";
 import { getArchivesBackblaze } from "../-a-archives/archivesBackBlaze";
 import { archiveJSONT } from "../-a-archives/archivesJSONT";
@@ -23,6 +24,7 @@ let prefixes = archiveJSONT<PrefixObj>(() => nestArchives("shard-prefixes/", get
 const key = "all";
 
 export async function getShardPrefixes(): Promise<string[]> {
+    if (!isNode()) return [];
     return (await prefixes.get(key))?.prefixes ?? [];
 }
 

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

@@ -5,7 +5,7 @@ import { isDiskAudit } from "../config";
 import { getPathFromStr } from "../path";
 import { auditLog } from "./auditLogs";
 import { PathRouter } from "./PathRouter";
-import { PathValue, authorityStorage, compareTime, debugPathValuePath, ReadLock, byLockGroup, isCoreQuiet, debugRejections, debugTime, debugPathValue } from "./pathValueCore";
+import { PathValue, authorityStorage, compareTime, debugPathValuePath, ReadLock, byLockGroup, isCoreQuiet, debugRejections, debugTime, debugPathValue, MAX_CHANGE_AGE } from "./pathValueCore";
 import { pathWatcher } from "./PathWatcher";
 import { lockWatcher2 } from "./LockWatcher2";
 import { onPathInteracted } from "../diagnostics/pathAuditerCallback";
@@ -82,7 +82,9 @@ class ValidStateComputer {
                         console.info(`Rejecting past value due to initial sync: ${debugPathValuePath(value)}`, {
                             path: value.path,
                             timeId: value.time.time,
+                            timeIdFull: value.time,
                             newTimeId: newValue?.time.time,
+                            newTimeIdFull: newValue?.time,
                         });
                         ourValues.push({ ...value, valid: false, });
                     }
@@ -158,10 +160,11 @@ class ValidStateComputer {
         }
         return !!value.valid;
     }
-    private isLockContentionFree(lock: ReadLock): PathValue | undefined {
+    private isLockContentionFree(lock: ReadLock): PathValue[] | undefined {
         // sorted by -time (newest are first)
         let history = authorityStorage.getValuePlusHistory(lock.path);
 
+        let conflictingValues: PathValue[] | undefined;
         let index = binarySearchIndex(history.length, i => compareTime(lock.endTime, history[i].time));
         if (index < 0) index = ~index;
         else index++;
@@ -172,10 +175,11 @@ class ValidStateComputer {
             if (value.isTransparent && lock.readIsTransparent) continue;
             // If value.time is within our range, there's contention!
             if (compareTime(lock.startTime, value.time) < 0 && compareTime(value.time, lock.endTime) < 0) {
-                return value;
+                if (!conflictingValues) conflictingValues = [];
+                conflictingValues.push(value);
             }
         }
-        return undefined;
+        return conflictingValues;
     }
 
     @measureFnc
@@ -193,6 +197,10 @@ class ValidStateComputer {
 
             let valid = true;
             for (let lock of locks) {
+                let age = now - lock.endTime.time;
+                // If it's old enough, then it's always valid, we can't change the valid save something after its max change age, even if it's invalid. 
+                if (age > MAX_CHANGE_AGE) continue;
+
                 if (!this.isLockValid(lock)) {
                     onPathInteracted(lock.path, 2);
                     valid = false;
@@ -259,7 +267,7 @@ class ValidStateComputer {
             }
         }
     }
-    private logLockContention(valueGroup: PathValue[], lock: ReadLock, conflictingValue: PathValue, now: number) {
+    private logLockContention(valueGroup: PathValue[], lock: ReadLock, conflictingValues: PathValue[], now: number) {
 
         // This special version indicates clientside prediction (which SHOULD be rejected).
         if (lock.endTime.version !== Number.MAX_SAFE_INTEGER) {
@@ -278,7 +286,7 @@ class ValidStateComputer {
                     redMessage += `\n    (original read from: ${debugTime(lock.startTime)}`;
                     redMessage += `\n    (at time: ${debugTime(lock.endTime)}`;
                     redMessage += `\n    (current time: ${Date.now()})`;
-                    redMessage += `\n    (conflict write at: ${debugTime(conflictingValue.time)}`;
+                    redMessage += `\n    (conflict write at: ${debugTime(conflictingValues[0].time)}`;
                     console.error(redMessage);
                 }
                 if (isDiskAudit()) {
@@ -287,11 +295,15 @@ class ValidStateComputer {
                             lock,
                             path: pathValue.path,
                             timeId: pathValue.time.time,
+                            timeIdVersion: pathValue.time.version,
+                            timeIdFull: pathValue.time,
                             lockedPath: lock.path,
                             transparent: lock.readIsTransparent,
                             missingPath: lock.path,
-                            conflictTimeId0: conflictingValue.time.time,
-                            conflictingWrites: conflictingValue,
+                            conflictTimeId0: conflictingValues[0].time.time,
+                            conflictTimeIdVersion0: conflictingValues[0].time.version,
+                            conflictCount: conflictingValues.length,
+                            conflictingWrites: conflictingValues,
                             hadTimeId: lock.startTime.time,
                         });
                     }

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

@@ -1,22 +1,15 @@
 import { measureWrap } from "socket-function/src/profiling/measure";
 import { getPathDepth, getPathIndexAssert, hack_getPackedPathSuffix, hack_setPackedPathSuffix, hack_stripPackedPath } from "../path";
-import { PathRouter } from "./PathRouter";
+import { AuthoritySpec, PathRouter } from "./PathRouter";
 import { cache } from "socket-function/src/caching";
 import { authorityLookup } from "./AuthorityLookup";
 
-// NOTE: This code has been moved into PathRouter
-// /** Returns a number between 0 (inclusive) and 1 (exclusive)
-//  *      - See matchesParentRangeFilter, matchesParentRangeFilterPart, and filterChildPaths.
-//  */
-// export function __getRoutingHash(key: string): number {
-//     // Using fastHash is about twice as fast as sha256 (although that might be due to the buffer allocation?)
-//     let hash = fastHash(key);
-//     return hash % (1000 * 1000 * 1000) / (1000 * 1000 * 1000);
-//     // let hash = sha256(key);
-//     // return getBufferFraction(Buffer.from(hash, "hex"));
-// }
 
-// NOTE: Assumes fullPath is already a child of parentPath, and only checks for hash
+let getSpecForChildPath = (path: string) => authorityLookup.getOurSpec();
+export function registerGetSpecForChildPath(fnc: (path: string) => AuthoritySpec) {
+    getSpecForChildPath = fnc;
+}
+
 export function matchesParentRangeFilter(config: {
     parentPath: string;
     fullPath: string;
@@ -26,33 +19,22 @@ export function matchesParentRangeFilter(config: {
     if (config.parentPath === config.packedPath) return true;
     let filter = decodeParentFilter(config.packedPath);
     if (!filter) return true;
-    let route = PathRouter.getRouteChildKey(config.fullPath);
+    if (filter.start <= 0 && filter.end >= 1) return true;
+    let route = PathRouter.getRouteFull({ path: config.fullPath, spec: getSpecForChildPath(config.fullPath) });
     return filter.start <= route && route < filter.end;
 }
-// export function matchesParentRangeFilterPart(config: {
-//     part: string;
-//     start: number;
-//     end: number;
-// }) {
-//     if (config.start === 0 && config.end === 1) return true;
-//     let hash = __getRoutingHash(config.part);
-//     return config.start <= hash && hash < config.end;
-// }
 
-// IMPORTANT! Child hashing is always based on the last key, never based on the full path. We need to make it always consistent, and we want it to work for parallel values. It cannot change depending on the routing, as this then becomes extremely complicated for proxies and for determining if we are actually supposed to be receiving a value from that node, and for the node to know what values it should send, etc. 
 export const filterChildPathsBase = measureWrap(
     function filterChildPathsBase(parentPath: string, packedSuffix: string, paths: Set<string>): Set<string> {
         let [startFractionStr, endFractionStr] = packedSuffix.split("|");
         let startFraction = Number(startFractionStr);
         let endFraction = Number(endFractionStr);
 
-        let depth = getPathDepth(parentPath);
-
         let filtered = new Set<string>();
         for (let path of paths) {
-            let key = getPathIndexAssert(path, depth);
-            let hash = PathRouter.getSingleKeyRoute(key);
-            if (startFraction <= hash && hash < endFraction) {
+            // TODO: We can make this significantly more efficient as once we know if it's a prefix or not, we know the underlying function call every time. However, that starts to get complicated, and I don't think this is going to be a bottleneck.
+            let route = PathRouter.getRouteFull({ path, spec: getSpecForChildPath(path) });
+            if (startFraction <= route && route < endFraction) {
                 filtered.add(path);
             }
         }

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

@@ -223,6 +223,7 @@ export class PathValueArchives {
         let totalSize = 0;
 
         let dataPaths: string[] = [];
+        let allPaths: string[] = [];
         let readCache = new Map<string, Buffer>();
 
         let downloadStartTime = Date.now();
@@ -233,8 +234,12 @@ export class PathValueArchives {
             //  the source file, but by now it has moved, so we don't see either file, even though at all times
             //  both files existed).
             let time = Date.now();
-            dataPaths = await this.getValuePaths(authority);
-            console.log(green(`${dataPaths.length} data paths in ${formatTime(Date.now() - time)}`));
+            let valueObjs = await this.getValuePaths(authority);
+            dataPaths = valueObjs.pickedPaths;
+            allPaths = valueObjs.allPaths;
+            let allValueCount = allPaths.reduce((acc, path) => acc + this.decodeDataPath(path).valueCount, 0);
+            let pickedValueCount = dataPaths.reduce((acc, path) => acc + this.decodeDataPath(path).valueCount, 0);
+            console.log(green(`${dataPaths.length}/${allPaths.length} (values ${formatNumber(pickedValueCount)} / ${formatNumber(allValueCount)}) data paths in ${formatTime(Date.now() - time)}`));
             // NOTE: If the notMatched count is high enough, it is possible NodePathAuthorities.ts:authoritiesMightOverlap is
             //  too loose, and should be removing more cases.
 
@@ -437,7 +442,10 @@ export class PathValueArchives {
     }
 
     @measureFnc
-    public async getValuePaths(authority: AuthoritySpec): Promise<string[]> {
+    public async getValuePaths(authority: AuthoritySpec): Promise<{
+        pickedPaths: string[];
+        allPaths: string[];
+    }> {
         // let paths: string[] = [];
         // let pickedDirectories = await this.getAuthorityDirs(authority);
 
@@ -450,8 +458,11 @@ export class PathValueArchives {
 
         let locker = await this.getArchiveLocker();
         let allFiles = (await locker.getAllValidFiles()).map(x => x.file);
-        let doesMatch = cache((dir: string) => PathRouter.overlapsPathIdentifier(authority, dir));
-        return allFiles.filter(x => doesMatch(x.split("/").slice(0, -1).join("/")));
+        let pickedPaths = allFiles.filter(x => PathRouter.overlapsPathIdentifier(authority, x));
+        return {
+            pickedPaths,
+            allPaths: allFiles,
+        };
     }
     @measureFnc
     public async getValuePathSizes(paths: string[]): Promise<number[]> {

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

@@ -24,6 +24,8 @@ import { fastHash } from "../misc/hash";
 import { authorityLookup } from "./AuthorityLookup";
 import { onPathInteracted } from "../diagnostics/pathAuditerCallback";
 import { decodeParentFilter, filterChildPathsBase } from "./hackedPackedPathParentFiltering";
+import { isDiskAudit } from "../config";
+import { removeRange } from "../rangeMath";
 
 setImmediate(async () => {
     // Import everything will dynamically import, so the client side can tell that it's required. 
@@ -543,6 +545,9 @@ class AuthorityPathValueStorage {
         if (this.DEBUG_UNWATCH) {
             console.log(blue(`Unsyncing path at ${Date.now()}`), path);
         }
+        if (isDiskAudit()) {
+            auditLog("DESTROY PATH", { path });
+        }
 
         this.isSyncedCache.delete(path);
         this.removePathFromStorage(path, "unwatched");
@@ -604,11 +609,45 @@ class AuthorityPathValueStorage {
         return false;
     }
     public isParentSynced(path: string) {
+        let range = decodeParentFilter(path);
         path = hack_stripPackedPath(path);
-        // We have to check a test child path to see if we are a self authority
-        if (PathRouter.isSelfAuthority(appendToPathStr(path, ""))) return true;
+        if (PathRouter.isLocalPath(path)) return true;
+
+        let synced = this.parentsSynced.get(path);
+        if (synced === true) return true;
+        // See if the ranges received so far cover the requested range. If we only request a partial range, then this will always be the case. We'll never fully synchronize the path. 
+        if (synced && range) {
+            let missingRanges: { start: number; end: number }[] = [{ start: range.start, end: range.end }];
+            for (let range of synced) {
+                removeRange(missingRanges, range);
+            }
+            if (missingRanges.length === 0) return true;
+        }
 
-        return this.parentsSynced.get(path) === true;
+        // Self authority check
+        {
+            let nodes = PathRouter.getChildReadNodes(path, { onlyOwnNodes: true });
+            if (nodes.nodes.length > 0) {
+                if (nodes.nodes.every(x => isOwnNodeId(x.nodeId))) {
+                    // If it's not a partial 30 and we're self authority, we're always going to be self authority, so we can just cache it in the lookup. 
+                    this.parentsSynced.set(path, true);
+                    return true;
+                }
+                // Might be a partial authority
+                if (range) {
+                    let selfNodes = nodes.nodes.filter(x => isOwnNodeId(x.nodeId));
+                    let missingRanges: { start: number; end: number }[] = [{ start: range.start, end: range.end }];
+                    for (let range of selfNodes) {
+                        removeRange(missingRanges, range.range);
+                    }
+                    if (missingRanges.length === 0) {
+                        return true;
+                    }
+                }
+            }
+        }
+
+        return false;
     }
 
     /** Obviously just for debugging. Doesn't trigger any watchers, just erases it as if we never had it. There shouldn't be really any downstream caches within the same process at least, and so this should result in the next read having the value missing. If we in the future add downstream caches, we're going to have to invalidate them as well.
@@ -1052,6 +1091,7 @@ class AuthorityPathValueStorage {
         let { spec, startTime, endTime } = config;
         let result: PathValue[] = [];
         for (let [path, values] of this.values) {
+            if (PathRouter.isLocalPath(path)) continue;
             if (PathRouter.matchesAuthoritySpec(spec, path)) {
                 for (let value of values) {
                     let time = value.time.time;