querysub 0.402.0 → 0.404.0

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

@@ -0,0 +1,535 @@
+import { sort } from "socket-function/src/misc";
+import { getLastPathPart, getPathDepth, getPathIndex, getPathStr1 } from "../path";
+import { AuthorityEntry, authorityLookup } from "./AuthorityLookup";
+import { PathValue } from "./pathValueCore";
+import { shuffle } from "../misc/random";
+import { fastHash } from "../misc/hash";
+import { getOwnNodeId, isOwnNodeId } from "../-f-node-discovery/NodeDiscovery";
+import { unique } from "../misc";
+import { measureFnc } from "socket-function/src/profiling/measure";
+import { getRoutingOverride, hasPrefixHash } from "./PathRouterRouteOverride";
+import { sha256 } from "js-sha256";
+
+
+// Cases
+// 1) Whole path hash
+// 2) Prefix + child override
+// 3) Special key override (for calls, so we can shard by function)
+
+
+
+
+export const LOCAL_DOMAIN = "LOCAL";
+export const LOCAL_DOMAIN_PATH = getPathStr1(LOCAL_DOMAIN);
+
+// NOTE: The goal is for a user on the site to require talking to as few authorities as possible. Because most things are nested in lookups, if we have a prefix per root lookup, this should mean if you're on a page, most of the data should be talking to the same authority, as most of the data should have the exact same hash.
+//  - We also support the exclude default case, which allows you to only handle certain prefixes, so you can make a function only run on certain servers.
+export type AuthoritySpec = {
+    nodeId: string;
+    // If we don't match a value in remaps, we hash `path`. UNLESS excludeDefault, then we just don't match it (probably with a hash of -1, so it doesn't match our range).
+    //  - And paths can also override the hash based on the path itself, ex, to force the hash to be 0, or 0.4, etc.
+    routeStart: number;
+    routeEnd: number;
+    // If the path.startsWith(prefix), but prefix !== path, then we hash getPathIndex(path, hashIndex)
+    //  - For now, let's just never add overlapping prefixes.
+    prefixes: {
+        prefix: string;
+        hashIndex: number;
+    }[];
+    excludeDefault?: boolean;
+};
+
+
+export class PathRouter {
+
+    public static async waitUntilReady() {
+        await authorityLookup.startSyncing();
+    }
+    /** NOTE: Parent watches are a little bit special. If it's a parent watch, we always hash it, assuming the parent is a prefix. And as most of the watches are parent watches, we're usually going to do this, and so it actually is independent of the topology. 
+        - The topology is really only used for the initial sync, which will use matchesAuthoritySpec, which gets the full routing value, AND, for disk storage.
+     */
+    @measureFnc
+    public static getRouteChildKey(path: string): number {
+        let key = getLastPathPart(path);
+        return this.getSingleKeyRoute(key);
+    }
+    // NOTE: For non-prefix values, breaking up by routes on the file system becomes complicated, and so we just all non-prefix values in the same file. However, in memory, in some places, we need route values for every single path, such as for FunctionRunner, so it can distribute the function running evenly, without overlap.
+    @measureFnc
+    private static getRouteFull(config: {
+        path: string;
+        spec: AuthoritySpec;
+    }): number {
+        // NOTE: getSelfPathIdentifierTargets also hardcodes this logic, so it can hash many values quickly
+        let { path, spec } = config;
+        let override = getRoutingOverride(path);
+        if (override) {
+            if (!hasPrefixHash({ spec, prefixHash: override.prefixHash })) return -1;
+            return override.route;
+        }
+
+        let prefix = spec.prefixes.find(x => path.startsWith(x.prefix) && x.prefix !== path);
+        if (prefix) {
+            let key = getPathIndex(path, prefix.hashIndex);
+            if (key === undefined) throw new Error(`Impossible, hash index ${prefix.hashIndex} is out of range for path ${path}, but it matched the prefix ${prefix.prefix}`);
+            return this.getSingleKeyRoute(key);
+        }
+        if (spec.excludeDefault) return -1;
+        let hash = this.getSingleKeyRoute(path);
+        if (hash < spec.routeStart || hash >= spec.routeEnd) return -1;
+        return hash;
+    }
+
+    private static lastKeyRoute = {
+        key: "",
+        route: -1,
+    };
+    // Takes a key which is a part of a path. Mostly used PathRouterRouteOverride, or other PathRouter helpers.
+    public static getSingleKeyRoute(key: string): number {
+        if (key && this.lastKeyRoute.key === key) return this.lastKeyRoute.route;
+        let hash = fastHash(key);
+        let route = hash % (1000 * 1000 * 1000) / (1000 * 1000 * 1000);
+        this.lastKeyRoute.key = key;
+        this.lastKeyRoute.route = route;
+        return route;
+    }
+
+
+    @measureFnc
+    public static matchesAuthoritySpec(authoritySpec: AuthoritySpec, path: string): boolean {
+        let route = this.getRouteFull({ path, spec: authoritySpec });
+        return authoritySpec.routeStart <= route && route < authoritySpec.routeEnd;
+    }
+
+
+    private static getPrefixHash(prefix: string): string {
+        return Buffer.from(sha256(prefix), "hex").toString("base64").slice(0, 6);
+    }
+    private static encodeIdentifier(config: { prefixes: string[]; rangeStart: number; rangeEnd: number } | "remaining"): string {
+        if (config === "remaining") return "P!REMAINING";
+        let { prefixes, rangeStart, rangeEnd } = config;
+        return ["P", rangeStart.toString(), rangeEnd.toString(), ...prefixes.map(x => this.getPrefixHash(x))].join("!");
+
+    }
+    private static decodeIdentifier(identifier: string): { prefixHashes: string[]; rangeStart: number; rangeEnd: number } | "remaining" {
+        if (!identifier.startsWith("P")) return "remaining";
+        let parts = identifier.split("!");
+        if (parts[1] === "REMAINING") return "remaining";
+        return {
+            rangeStart: parseFloat(parts[1]),
+            rangeEnd: parseFloat(parts[2]),
+            prefixHashes: parts.slice(3),
+        };
+    }
+
+    // Allows you to create a folder on disk, and then later (with overlapsPathIdentifier) know which authorities have overlapping data (and so they need to read from that folder for their data).
+    // NOTE: Encodes all the data, even if it matches our spec or not. If you don't want this, you have to filter first
+    //  - If this becomes an issue we COULD filter, as we can do it quickly, but I don't think it is required, as all the present usecases prefilter anyways.
+    @measureFnc
+    public static getSelfPathIdentifierTargets(values: PathValue[]): Map<string, PathValue[]> {
+        // NOTE: The file size limit is 1024 bytes. But we also have our folder, etc, so we want to add enough buffer
+        //  - Shorter hashes means we can store more, but there's a point when the collisions make it less useful.
+        const MAX_PREFIXES_PER_FILE = 50;
+        const PREFIX_COVER_FRACTION = 0.95;
+        const TARGET_VALUES_PER_FILE = 50 * 1000;
+        if (values.length < TARGET_VALUES_PER_FILE) {
+            return new Map([[this.encodeIdentifier("remaining"), values]]);
+        }
+
+        let ourSpec = authorityLookup.getOurSpec();
+
+        let prefixes = ourSpec.prefixes.slice();
+        sort(prefixes, x => x.prefix.length);
+        function getPrefix(path: string): string | undefined {
+            for (let prefix of prefixes) {
+                if (path.startsWith(prefix.prefix)) return prefix.prefix;
+            }
+            return undefined;
+        }
+
+
+        // NOTE: If there are few enough path values for a prefix, we don't even need to calculate the routing hash. 
+        let byPrefix = new Map<string | undefined, PathValue[]>();
+        for (let value of values) {
+            let prefix = getPrefix(value.path);
+            let values = byPrefix.get(prefix);
+            if (!values) {
+                values = [];
+                byPrefix.set(prefix, values);
+            }
+            values.push(value);
+        }
+
+        let prefixGroups = Array.from(byPrefix.entries()).map(([prefix, values]) => ({
+            prefix,
+            values,
+        }));
+        sort(prefixGroups, x => -x.values.length);
+
+        let groups: {
+            prefixes: string[];
+            values: PathValue[][];
+            count: number;
+        }[] = [];
+        let remainingValues: PathValue[][] = [];
+        groups.push({
+            prefixes: [],
+            values: [],
+            count: 0,
+        });
+        let prefixLeft = Math.round(values.length * PREFIX_COVER_FRACTION);
+        for (let prefixGroup of prefixGroups) {
+            if (prefixGroup.prefix === undefined) {
+                remainingValues.push(prefixGroup.values);
+                continue;
+            }
+            if (prefixLeft < 0) {
+                remainingValues.push(prefixGroup.values);
+                continue;
+            }
+            let last = groups[groups.length - 1];
+            if (
+                last.count > 0 && last.count + prefixGroup.values.length > TARGET_VALUES_PER_FILE
+                || last.prefixes.length >= MAX_PREFIXES_PER_FILE
+            ) {
+                groups.push({
+                    prefixes: [],
+                    values: [],
+                    count: 0,
+                });
+                last = groups[groups.length - 1];
+            }
+            last.prefixes.push(prefixGroup.prefix);
+            last.values.push(prefixGroup.values);
+            last.count += prefixGroup.values.length;
+            prefixLeft -= prefixGroup.values.length;
+        }
+
+
+        let finalFiles = new Map<string, PathValue[]>();
+        for (let group of groups) {
+            if (group.prefixes.length === 1 && group.count > TARGET_VALUES_PER_FILE) {
+                // Split by routing hash
+                let values = group.values.flat();
+                let splitCount = Math.ceil(values.length / TARGET_VALUES_PER_FILE);
+                let byRouteGroup = new Map<number, PathValue[]>();
+                let prefix = group.prefixes[0];
+                let hashIndex = getPathDepth(prefix);
+                for (let value of values) {
+                    let key = getPathIndex(value.path, hashIndex);
+                    if (key === undefined) throw new Error(`Impossible, hash index ${hashIndex} is out of range for path ${value.path}, but it matched the prefix ${prefix}`);
+                    let route = this.getSingleKeyRoute(key);
+                    let routeIndex = Math.floor(route * splitCount);
+                    let routeValues = byRouteGroup.get(routeIndex);
+                    if (!routeValues) {
+                        routeValues = [];
+                        byRouteGroup.set(routeIndex, routeValues);
+                    }
+                    routeValues.push(value);
+                }
+                for (let [routeIndex, routeValues] of byRouteGroup) {
+                    let rangeStart = routeIndex / splitCount;
+                    let rangeEnd = (routeIndex + 1) / splitCount;
+                    let identifier = this.encodeIdentifier({ prefixes: [prefix], rangeStart, rangeEnd });
+                    finalFiles.set(identifier, routeValues);
+                }
+            } else {
+                let identifier = this.encodeIdentifier({ prefixes: group.prefixes, rangeStart: 0, rangeEnd: 1 });
+                finalFiles.set(identifier, group.values.flat());
+            }
+        }
+
+        if (remainingValues.length > 0) {
+            let identifier = this.encodeIdentifier("remaining");
+            finalFiles.set(identifier, remainingValues.flat());
+        }
+
+        return finalFiles;
+    }
+
+    // NOTE: We just look at the prefix of identifier, so you can add anything after it, if you want
+    @measureFnc
+    public static overlapsPathIdentifier(authority: AuthoritySpec, identifier: string): boolean {
+        let decodeObj = this.decodeIdentifier(identifier);
+        // Match all remaining, as we don't store enough information to know what prefixes they excluded
+        if (decodeObj === "remaining") return true;
+
+        let ourHashes = authority.prefixes.map(x => this.getPrefixHash(x.prefix));
+        // If it pulled off some values as prefixes, but we did full path hashes, then the hashes are going to be totally different. And so there could easily be overlap.
+        if (decodeObj.prefixHashes.some(x => !ourHashes.includes(x))) return true;
+        // However, if we hash everything the same, then the overlap is purely a case of if the route ranges overlap. 
+        return decodeObj.rangeStart < authority.routeEnd && decodeObj.rangeEnd > authority.routeStart;
+    }
+
+
+
+    public static isLocalPath(path: string): boolean {
+        return path.startsWith(LOCAL_DOMAIN_PATH);
+    }
+    @measureFnc
+    public static isSelfAuthority(path: string): boolean {
+        if (this.isLocalPath(path)) return true;
+        let ourSpec = authorityLookup.getOurSpec();
+        return this.matchesAuthoritySpec(ourSpec, path);
+    }
+
+
+
+    // NOTE: This might return overlapping specs. Presently, this is only used when we're loading our initial data, so it's fine. However, if we use this for another purpose in the future, it might cause problems. So we might need to implement a different function for that theoretical future purpose.
+    @measureFnc
+    public static getAuthoritySources(config: {
+        target: AuthoritySpec;
+        preferredNodeIds?: string[];
+    }): (AuthoritySpec & { useFullPathHash?: boolean })[] {
+        let { target } = config;
+        let allSources = authorityLookup.getTopologySync();
+        allSources = allSources.filter(x => !isOwnNodeId(x.nodeId));
+        // THIS is normal during initial server startup
+        if (!allSources.length) {
+            return [];
+        }
+        // If the target doesn't exclude default the source cannot exclude the default.
+        if (!target.excludeDefault) {
+            allSources = allSources.filter(x => !x.authoritySpec.excludeDefault);
+        }
+
+        // Basically... Authority specs have different prefixes, that means their overlap is inconsistent. So you can't take part of one and part of the other. That doesn't make any sense. HOWEVER, 99% of the time everything SHOULD be cohesive. AND, when it isn't, then It means we are in the process of a transition, in which case there might be two groups. If there's a hundred different cohesive groups... something is very broken
+        let cohesiveGroups: AuthoritySpec[][] = [];
+
+        let groupByPrefixHash = new Map<string, AuthoritySpec[]>();
+        for (let source of allSources) {
+            let usedPrefixes = source.authoritySpec.prefixes.map(x => x.prefix);
+
+            if (target.excludeDefault) {
+                // This relaxes the restrictions, as with no default hashes, it means if a value isn't in one of our prefixes, even if it's inconsistent in the sources, it's fine. 
+                // (And... Otherwise, we can't filter these at all because otherwise the default/remaining group will be different, even if it's a superset/subset relationship)
+                let targetUsedPrefixes = new Set(target.prefixes.map(x => x.prefix));
+                usedPrefixes = usedPrefixes.filter(x => targetUsedPrefixes.has(x));
+            }
+            let prefixHash = sha256(JSON.stringify(usedPrefixes.sort()));
+            let group = groupByPrefixHash.get(prefixHash);
+            if (!group) {
+                group = [];
+                groupByPrefixHash.set(prefixHash, group);
+            }
+            group.push(source.authoritySpec);
+        }
+        cohesiveGroups = Array.from(groupByPrefixHash.values());
+
+
+        if (cohesiveGroups.length > 4) {
+            console.error(`Authority prefixes in our topology have been inconsistent, with ${cohesiveGroups.length} different groups. This SHOULD be fixable by restarting the PathValueServers. If this doesn't fix it, it means there is an issue with how we are loading our data.`);
+        }
+
+        function hashesSameAsTarget(spec: AuthoritySpec): boolean {
+            let targetUsedPrefixes = new Set(target.prefixes.map(x => x.prefix));
+            if (target.excludeDefault) {
+                // If target is excluding default, then it doesn't matter if the spec is including it. We're only looking for matching values in target.
+                return spec.prefixes.every(x => targetUsedPrefixes.has(x.prefix));
+            }
+            // if !targetExcludeDefault, then !spec.excludeDefault, because we filtered out other cases earlier (so we don't need to handle spec.
+
+            if (spec.prefixes.length !== target.prefixes.length) return false;
+            // Otherwise, All of the prefixes have to be identical
+            for (let prefix of spec.prefixes) {
+                if (!targetUsedPrefixes.has(prefix.prefix)) return false;
+            }
+            return true;
+        }
+
+        shuffle(cohesiveGroups, Math.random());
+        sort(cohesiveGroups, x => hashesSameAsTarget(x[0]) ? -1 : 1);
+
+        let preferredNodeIds = new Set(config?.preferredNodeIds ?? []);
+        for (let group of cohesiveGroups) {
+            shuffle(group, Math.random());
+            sort(group, x => preferredNodeIds.has(x.nodeId) ? -1 : 1);
+            let targetStart = target.routeStart;
+            let targetEnd = target.routeEnd;
+            // If the group doesn't hash the same way we do, then we need to expand our range to be the full range of the group, so we don't miss anything.
+            let useFullPathHash = !hashesSameAsTarget(group[0]);
+            if (useFullPathHash) {
+                targetStart = 0;
+                targetEnd = 1;
+            }
+
+            let missingRanges: { start: number; end: number }[] = [{
+                start: targetStart,
+                end: targetEnd,
+            }];
+            let usedParts: (AuthoritySpec & { useFullPathHash?: boolean })[] = [];
+            for (let source of group) {
+                let s = source.routeStart;
+                let e = source.routeEnd;
+                // Find if it overlaps any missing range, and if so, cut out that part of the missing change, and add the nodeId to usedNodeIds
+                for (let i = missingRanges.length - 1; i >= 0; i--) {
+                    let missingRange = missingRanges[i];
+                    if (s >= missingRange.end || e <= missingRange.start) continue;
+                    let startTaken = Math.max(missingRange.start, s);
+                    let endTaken = Math.min(missingRange.end, e);
+                    // NOTE: It's not ideal that we might have to fragment one node ID between multiple requests. However, in practice, there shouldn't be much fragmentation here. The ranges that our nodes are breaking down by should be consistent, so there's actually no overlap or subsets.
+                    usedParts.push({
+                        nodeId: source.nodeId,
+                        routeStart: startTaken,
+                        routeEnd: endTaken,
+                        prefixes: target.prefixes,
+                        excludeDefault: target.excludeDefault,
+                        useFullPathHash,
+                    });
+                    missingRanges.splice(i, 1);
+                    // Add back the parts we didn't overlap
+                    if (missingRange.start < s) {
+                        missingRanges.push({
+                            start: missingRange.start,
+                            end: s,
+                        });
+                    }
+                    if (missingRange.end > e) {
+                        missingRanges.push({
+                            start: e,
+                            end: missingRange.end,
+                        });
+                    }
+                }
+                if (missingRanges.length === 0) break;
+            }
+            if (missingRanges.length === 0) {
+                if (!hashesSameAsTarget(group[0])) {
+                    console.warn(`Found a cohesive group that doesn't hash the same way we do. Expanding our range to be the full range of the group. This will be slower than it needs to.`);
+                }
+                return usedParts;
+            }
+        }
+
+        allSources = authorityLookup.getTopologySync().filter(x => !isOwnNodeId(x.nodeId));
+        console.error(`No consistent authority sources found for our entire range of ${target.routeStart} to ${target.routeEnd}. We tried ${cohesiveGroups.length} cohesive groups, from ${allSources.length} sources. Falling back to all sources (which will be slow).`);
+        return allSources.map(x => x.authoritySpec);
+    }
+
+
+    @measureFnc
+    public static getChildReadNodes(path: string, config?: {
+        preferredNodeIds?: string[];
+    }): {
+        // By default we hash the key directly under the path. However, If that is not how our nodes were sharded, as in they didn't use it as a prefix, then they will be sharded by hashing the full path, and so when we receive the data, we need to keep this in mind and filter the data based on the full path hash.
+        useFullPathHash?: boolean;
+
+        // NOTE: If at all possible, we will cover all ranges. Node of the returned nodes will be redundant.
+        //  - Sorted by range.start
+        nodes: {
+            nodeId: string;
+            // The range of hashes this node owns, for the child keys of path
+            //  (If the node doesn't restrict the range, it will just be { start: 0, end: 1 })
+            range: { start: number; end: number };
+        }[];
+    } {
+        if (this.isSelfAuthority(path)) {
+            return { nodes: [{ nodeId: getOwnNodeId(), range: { start: 0, end: 1 } }] };
+        }
+
+        // If a prefix is a parent of path, then it is the same as matching just the path directly
+        // (If our prefix directly equals one of the other matches, then it's more complicated, As then, the child keys of path are what is hashed, and so all the children will have different routes, so we might match multiple nodes. The same thing if we're matching the remaining case, in which case it's a full path hash, so the child key matters, and again, different routes).
+        //      - The different route case is how the FuntionRunner works, and without it large databases couldn't run functions. However, most applications won't directly use it.
+        let allSources = authorityLookup.getTopologySync();
+        allSources = allSources.filter(x => !isOwnNodeId(x.nodeId));
+        let nestedMatches = allSources.filter(x =>
+            x.authoritySpec.prefixes.some(y => path.startsWith(y.prefix) && y.prefix !== path)
+            && this.matchesAuthoritySpec(x.authoritySpec, path)
+        );
+        if (nestedMatches.length > 0) {
+            shuffle(nestedMatches, Math.random());
+            let preferredNodeIds = new Set(config?.preferredNodeIds ?? []);
+            sort(nestedMatches, x => preferredNodeIds.has(x.nodeId) ? -1 : 1);
+            return {
+                nodes: nestedMatches.map(x => ({
+                    nodeId: x.nodeId,
+                    // NOTE: Our path is picked by the prefix, and the prefix only hashes the direct child, and we're more deeply nested than that, which means... the route for all of our children will be identical, so this node matches all of our children. 
+                    range: { start: 0, end: 1 },
+                })),
+            };
+        }
+
+        let fullSources = this.getAuthoritySources({
+            target: {
+                nodeId: "",
+                prefixes: [{
+                    prefix: path,
+                    hashIndex: getPathDepth(path),
+                }],
+                routeStart: 0,
+                routeEnd: 1,
+                excludeDefault: true,
+            },
+            preferredNodeIds: config?.preferredNodeIds,
+        });
+        if (fullSources.length === 0) return { nodes: [] };
+
+        return {
+            useFullPathHash: fullSources.some(x => x.useFullPathHash),
+            nodes: fullSources.map(x => ({
+                nodeId: x.nodeId,
+                range: { start: x.routeStart, end: x.routeEnd },
+            })),
+        };
+    }
+
+
+
+    @measureFnc
+    public static getReadyAuthorities(path: string): AuthorityEntry[] {
+        return this.getAllAuthorities(path).filter(x => x.isReady);
+    }
+    @measureFnc
+    public static getReadyAuthority(path: string): AuthorityEntry | undefined {
+        let candidates = authorityLookup.getTopologySync();
+        shuffle(candidates, Math.random());
+        for (let candidate of candidates) {
+            if (!candidate.isReady) continue;
+            if (this.matchesAuthoritySpec(candidate.authoritySpec, path)) {
+                return candidate;
+            }
+        }
+        return undefined;
+    }
+    @measureFnc
+    public static getAllAuthorities(path: string): AuthorityEntry[] {
+        let entries: AuthorityEntry[] = [];
+        let candidates = authorityLookup.getTopologySync();
+        for (let candidate of candidates) {
+            if (!candidate.isReady) continue;
+            if (this.matchesAuthoritySpec(candidate.authoritySpec, path)) {
+                entries.push(candidate);
+            }
+        }
+        return entries;
+    }
+
+    @measureFnc
+    public static getAllAuthorityNodes(path: string): string[] {
+        let authorities = this.getAllAuthorities(path);
+        return unique(authorities.map(x => x.nodeId));
+    }
+
+
+
+    // Returns nodeId => T[] (each T might be mapped to many nodeIds)
+    @measureFnc
+    public static getAllAuthoritiesForValues<T extends { path: string }>(values: T[]): Map<string, T[]> {
+        let valuesPerOtherAuthority = new Map<string, T[]>();
+        for (let pathValue of values) {
+            let otherAuthorities = PathRouter.getAllAuthorityNodes(pathValue.path);
+            for (let otherAuthority of otherAuthorities) {
+                if (isOwnNodeId(otherAuthority)) continue;
+
+                let values = valuesPerOtherAuthority.get(otherAuthority);
+                if (!values) {
+                    values = [];
+                    valuesPerOtherAuthority.set(otherAuthority, values);
+                }
+                values.push(pathValue);
+            }
+        }
+        return valuesPerOtherAuthority;
+    }
+
+}
+

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

@@ -0,0 +1,72 @@
+import { cacheLimited } from "socket-function/src/caching";
+import { AuthoritySpec, PathRouter } from "./PathRouter";
+import { sha256 } from "js-sha256";
+import { getPathFromStr } from "../path";
+
+function getPrefixHash(prefix: string): string {
+    return Buffer.from(sha256(prefix), "hex").toString("base64").slice(0, 12);
+}
+
+// So... should be use unicode characters?
+//  - Both to ensure all of our code supports them in keys, and because it allows us to us a lot fewer characters.
+// NOTE: If we want, we could add code to prevent users from creating keys that use these. However, I think it's fine, because the querysub server is still the first node you talk to, so it can throttle your traffic. ALSO, ideally all of your traffic DOES go to the same PathValueServer. That's why prefix routing exists. And PathValueServers should be able to handle A LOT of traffic.
+let keySpecialIdentifier = (
+    "ROUTE_"
+    + String.fromCharCode(0xE1A4)
+    + String.fromCharCode(0xE8B2)
+    + String.fromCharCode(0xF0C9)
+    + String.fromCharCode(0xF4D7)
+);
+
+// NOTE: ONLY works for direct accesses, not for child key accesses. Also, it only works if the prefix is matched. If nothing matches the prefix, then this will actually make it not match any authorities.
+export function createRoutingOverrideKey(config: {
+    originalKey: string;
+    routeKey: string;
+    // This is not the prefix that it has to match. This is the prefix we remap it to. And so anything which matches this remap prefix will match this routing key. 
+    remappedPrefix: string;
+}) {
+    let { originalKey, routeKey, remappedPrefix } = config;
+    let route = PathRouter.getSingleKeyRoute(routeKey);
+    return keySpecialIdentifier + "!" + getPrefixHash(remappedPrefix) + "!" + route.toString().slice(0, 7) + "!" + originalKey;
+}
+
+export function getRoutingOverride(path: string): {
+    route: number;
+    prefixHash: string;
+} | undefined {
+    if (!path.includes(keySpecialIdentifier)) return undefined;
+    let parts = getPathFromStr(path);
+    for (let part of parts) {
+        let obj = getRoutingOverridePart(part);
+        if (obj) return obj;
+    }
+    return undefined;
+}
+export function getRoutingOverridePart(part: string): {
+    prefixHash: string;
+    route: number;
+} | undefined {
+    if (!part.startsWith(keySpecialIdentifier)) return undefined;
+    let parts = part.split("!");
+    if (parts.length < 4) return undefined;
+    let prefixHash = parts[1];
+    let route = parseFloat(parts[2]);
+    if (isNaN(route)) return undefined;
+    return {
+        prefixHash,
+        route,
+    };
+}
+
+export const hasPrefixHash = cacheLimited(1000 * 10,
+    (config: { spec: AuthoritySpec, prefixHash: string }) => {
+        let { spec, prefixHash } = config;
+        for (let prefix of spec.prefixes) {
+            if (getPrefixHash(prefix.prefix) === prefixHash) {
+                return true;
+            }
+        }
+        return false;
+    }
+);
+

package/src/0-path-value-core/PathRouterServerAuthoritySpec.tsx

@@ -0,0 +1,65 @@
+import path from "path";
+import { AuthoritySpec } from "./PathRouter";
+import { getPathDepth } from "../path";
+import { getAuthorityRange, getAuthorityExcludeDefault, getAuthorityPrefix } from "../config";
+import { getShardPrefixes } from "./ShardPrefixes";
+import { getOwnNodeId } from "../-f-node-discovery/NodeDiscovery";
+
+export async function getOurAuthoritySpec(defaultToAll: true): Promise<AuthoritySpec>;
+export async function getOurAuthoritySpec(defaultToAll?: boolean): Promise<AuthoritySpec | undefined>;
+export async function getOurAuthoritySpec(defaultToAll?: boolean): Promise<AuthoritySpec | undefined> {
+    let prefixes = await getShardPrefixes();
+
+    const range = getAuthorityRange();
+    const excludeDefault = getAuthorityExcludeDefault();
+    const cmdPrefixes = getAuthorityPrefix();
+
+    if (!range) {
+        if (defaultToAll) {
+            return getAllAuthoritySpec();
+        }
+        return undefined;
+    }
+
+    const [startStr, endStr] = range.split("-");
+    const rangeStart = parseFloat(startStr);
+    const rangeEnd = parseFloat(endStr);
+
+    if (isNaN(rangeStart) || isNaN(rangeEnd)) {
+        throw new Error(`Invalid authority range, should be in the format "0.5-1.0": ${range}`);
+    }
+
+    let usePrefixes = prefixes;
+    if (cmdPrefixes && cmdPrefixes.length > 0) {
+        usePrefixes = cmdPrefixes;
+    }
+
+    return {
+        nodeId: "",
+        routeStart: rangeStart,
+        routeEnd: rangeEnd,
+        prefixes: usePrefixes.map(prefix => ({
+            prefix,
+            hashIndex: getPathDepth(prefix),
+        })),
+        excludeDefault: excludeDefault || undefined,
+    };
+}
+
+
+export function getEmptyAuthoritySpec(): AuthoritySpec {
+    return {
+        nodeId: "",
+        routeStart: -1,
+        routeEnd: -1,
+        prefixes: [],
+    };
+}
+export function getAllAuthoritySpec(): AuthoritySpec {
+    return {
+        nodeId: "",
+        routeStart: 0,
+        routeEnd: 1,
+        prefixes: [],
+    };
+}