querysub 0.508.0 → 0.509.0

package/bin/function-public.js

@@ -2,6 +2,8 @@
 
 process.argv.push("--nobreak");
 process.argv.push("--public");
+process.argv.push("--network");
+process.argv.push("public");
 
 require("typenode");
 require("../src/3-path-functions/PathFunctionRunnerMain");

package/bin/server.js

@@ -1,8 +1,6 @@
 #!/usr/bin/env node
 
 process.argv.push("--local");
-process.argv.push("--networkfile");
-process.argv.push("~/devnetwork.txt");
 
 require("typenode");
 require("../src/server.ts");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.508.0",
+  "version": "0.509.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
@@ -31,7 +31,6 @@
     "deploy": "./bin/deploy.js",
     "deploy-prefixes": "./bin/deploy-prefixes.js",
     "server": "./bin/server.js",
-    "server-dev": "./bin/server-dev.js",
     "server-public": "./bin/server-public.js",
     "function": "./bin/function.js",
     "function-public": "./bin/function-public.js",
@@ -71,10 +70,10 @@
     "pako": "^2.1.0",
     "peggy": "^5.0.6",
     "sliftutils": "^1.7.5",
-    "socket-function": "^1.2.4",
+    "socket-function": "^1.2.5",
     "terser": "^5.31.0",
     "typenode": "^6.6.1",
-    "typesafecss": "*",
+    "typesafecss": "^0.32.0",
     "yaml": "^2.5.0",
     "yargs": "^15.3.1"
   },

package/spec.txt

@@ -1,4 +1,9 @@
 
+todonext
+Review the network trakcing code again.
+    - Maybe manually refactor it
+Ensure there is no dumb sync code
+
 
 
 Trigger values

package/src/-f-node-discovery/NodeDiscovery.ts

@@ -24,7 +24,7 @@ import { logDisk } from "../diagnostics/logs/diskLogger";
 import { MaybePromise } from "socket-function/src/types";
 import { getPathStr2 } from "../path";
 
-let HEARTBEAT_INTERVAL = timeInMinute * 15;
+let HEARTBEAT_INTERVAL = timeInMinute * 5;
 // Interval which we check other heartbeats
 let CHECK_INTERVAL = HEARTBEAT_INTERVAL;
 // If the heartbeat is older than thing, it fails the dead check

package/src/-g-core-values/NodeCapabilities.ts

@@ -24,6 +24,7 @@ import { getPathStr2 } from "../path";
 import { PromiseObj } from "../promise";
 import { getTrueTimeOffset } from "socket-function/time/trueTimeShim";
 import { getGitRefLive } from "../4-deploy/git";
+import { getScheduledShutdownTime } from "./scheduledShutdown";
 setImmediate(() => {
     import("../diagnostics/MachineThreadInfo");
 });
@@ -139,6 +140,8 @@ export type NodeMetadata = {
     exposedControllers: string[];
     trueTimeOffset: number;
     gitRef: string;
+    // Set when the machine apply process has told us we will be shut down (due to a scheduled switchover)
+    scheduledShutdownTime?: number;
 };
 
 class NodeCapabilitiesControllerBase {
@@ -153,6 +156,7 @@ class NodeCapabilitiesControllerBase {
             exposedControllers: Array.from(SocketFunction.exposedClasses),
             trueTimeOffset: getTrueTimeOffset(),
             gitRef: await getGitRefLive(),
+            scheduledShutdownTime: getScheduledShutdownTime(),
         };
     }
 

package/src/-g-core-values/scheduledShutdown.ts

@@ -0,0 +1,48 @@
+/*
+    Tracks when OUR node is scheduled to shut down (told to us by the machine apply process when a service switchover is scheduled). Other systems watch this to gracefully wind down ahead of the shutdown (deregistering as an edge node, rehoming watched paths, etc). The time is also exposed in our NodeCapabilities metadata, so other nodes can stop using us before we shutdown.
+*/
+
+const IMMINENT_SHUTDOWN_WARNING_TIME = 60_000;
+
+let scheduledShutdownTime: number | undefined;
+let watchers = new Set<(time: number) => void>();
+let imminentLogTimer: ReturnType<typeof setTimeout> | undefined;
+
+export function getScheduledShutdownTime(): number | undefined {
+    return scheduledShutdownTime;
+}
+
+export function setScheduledShutdownTime(time: number) {
+    console.log(`Our node is scheduled to shut down at ${new Date(time).toLocaleString()} (in ${Math.round((time - Date.now()) / 1000)}s) due to a service switchover`);
+    scheduledShutdownTime = time;
+
+    if (imminentLogTimer) {
+        clearTimeout(imminentLogTimer);
+        imminentLogTimer = undefined;
+    }
+    // setTimeout overflows (fires immediately) past ~24.8 days, and switchovers can be scheduled weeks out, so re-arm until we're within range.
+    const MAX_TIMEOUT_DELAY = 2 ** 31 - 1;
+    const armImminentLog = () => {
+        let delay = time - Date.now() - IMMINENT_SHUTDOWN_WARNING_TIME;
+        if (delay > MAX_TIMEOUT_DELAY) {
+            imminentLogTimer = setTimeout(armImminentLog, MAX_TIMEOUT_DELAY);
+            return;
+        }
+        imminentLogTimer = setTimeout(() => {
+            console.log(`We are about to be shut down due to a service switchover, at ${new Date(time).toLocaleString()}`);
+        }, Math.max(0, delay));
+    };
+    armImminentLog();
+
+    for (let watcher of watchers) {
+        watcher(time);
+    }
+}
+
+/** Calls the callback whenever our scheduled shutdown time is set or changed (immediately if it is already set). */
+export function watchScheduledShutdown(callback: (time: number) => void) {
+    watchers.add(callback);
+    if (scheduledShutdownTime !== undefined) {
+        callback(scheduledShutdownTime);
+    }
+}

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

@@ -11,21 +11,35 @@ import { IdentityController_getCurrentReconnectNodeIdAssert } from "../-c-identi
 import { requiresNetworkTrustHook } from "../-d-trust/NetworkTrust2";
 import { isClient } from "../config2";
 import { getPathStr1 } from "../path";
-import { timeoutToError } from "../errors";
+import { logErrors, timeoutToError } from "../errors";
 import { AuthoritySpec, parsePrefixMatcher } from "./PathRouter";
+
 import { formatTime } from "socket-function/src/formatting/format";
 import { getAllAuthoritySpec, getEmptyAuthoritySpec } from "./PathRouterServerAuthoritySpec";
+import { getScheduledShutdownTime, watchScheduledShutdown } from "../-g-core-values/scheduledShutdown";
 
 setImmediate(() => import("../3-path-functions/syncSchema"));
 
 let NETWORK_POLL_INTERVAL = timeInMinute * 1;
 let CALL_TIMEOUT = timeInSecond * 5;
 
+// Every node's per-node poll is created together at discovery, so without jitter all of their
+//  networkSyncPaths calls fire in lockstep each NETWORK_POLL_INTERVAL — and when many nodes are
+//  dead their CALL_TIMEOUT waits pile up into one spike. Each node instead drifts an extra wait
+//  by its own random velocity (wrapping at this window), which spreads the calls out and keeps
+//  them from re-aligning over time. Kept small so no single sync is delayed by much.
+const SYNC_JITTER_WINDOW = timeInSecond * 10;
+
+// Nodes this close to their scheduled shutdown are avoided as sources (only used if nothing else can satisfy the request).
+const SHUTDOWN_AVOID_WINDOW = timeInMinute * 10;
+
 export type AuthorityEntry = {
     nodeId: string;
     authoritySpec: AuthoritySpec;
     entryReceivedTime: number;
     isReady: boolean;
+    // This can be far in the future (a switchover scheduled weeks out), so routing doesn't avoid the node immediately — only once within SHUTDOWN_AVOID_WINDOW (see nodeIsShuttingDownSoon).
+    scheduledShutdownTime?: number;
 };
 type AuthorityTopology = {
     // nodeId =>
@@ -127,15 +141,21 @@ class AuthorityLookup {
         });
         await Promise.all(promises);
         this.didInitialSync = true;
+
+        // Push our scheduled shutdown time to the other nodes right away, so they can start avoiding us (instead of waiting up to a full poll interval).
+        watchScheduledShutdown(() => {
+            logErrors(this.syncAllNow());
+        });
     });
 
 
-    private updatePaths(nodeId: string, spec: AuthoritySpec, isReady: boolean) {
+    private updatePaths(nodeId: string, spec: AuthoritySpec, isReady: boolean, scheduledShutdownTime?: number) {
         let entry: AuthorityEntry = {
             nodeId,
             authoritySpec: spec,
             entryReceivedTime: Date.now(),
             isReady,
+            scheduledShutdownTime,
         };
         let prevEntry = this.topology.nodes.get(nodeId);
         // Try to preserve === property where possible, so we can use it as a cache key
@@ -145,22 +165,36 @@ class AuthorityLookup {
         this.topology.nodes.set(nodeId, entry);
     }
 
-    public async networkSyncPaths(otherSpec: AuthoritySpec, isReady: boolean): Promise<{
+    public getScheduledShutdownTime(nodeId: string): number | undefined {
+        return this.topology.nodes.get(nodeId)?.scheduledShutdownTime;
+    }
+    public nodeIsShuttingDownSoon(nodeId: string): boolean {
+        let time = this.getScheduledShutdownTime(nodeId);
+        return time !== undefined && time - Date.now() < SHUTDOWN_AVOID_WINDOW;
+    }
+
+    public async networkSyncPaths(config: {
         spec: AuthoritySpec;
         isReady: boolean;
+        scheduledShutdownTime?: number;
+    }): Promise<{
+        spec: AuthoritySpec;
+        isReady: boolean;
+        scheduledShutdownTime?: number;
     }> {
         let nodeId = IdentityController_getCurrentReconnectNodeIdAssert();
-        this.updatePaths(nodeId, otherSpec, isReady);
+        this.updatePaths(nodeId, config.spec, config.isReady, config.scheduledShutdownTime);
         console.info(`Received network sync, returning our data`, {
             nodeId,
-            otherSpec,
-            isReady,
+            otherSpec: config.spec,
+            isReady: config.isReady,
             ourSpec: this.ourSpec,
             ourIsReady: this.ourIsReady,
         });
         return {
             spec: this.ourSpec,
             isReady: this.ourIsReady,
+            scheduledShutdownTime: getScheduledShutdownTime(),
         };
     }
 
@@ -169,9 +203,13 @@ class AuthorityLookup {
 
     private connectTo = cache((nodeId: string) => {
         let stopObj = { stop: false };
+        let syncJitter = Math.random() * NETWORK_POLL_INTERVAL;
+        let syncJitterVelocity = Math.random() * SYNC_JITTER_WINDOW;
         let promise = runInfinitePollCallAtStart(NETWORK_POLL_INTERVAL, async () => {
             // NOTE: We keep calling even on disconnect, until it is removed from node discovery, so we handle reconnections. AND if it is removed from node discovery and reconnects, that's fine, it will tell us about the rediscovery as if was a new node, and we will setup it again.
             await this.syncNodeSerial(nodeId)();
+            syncJitter = (syncJitter + syncJitterVelocity) % SYNC_JITTER_WINDOW;
+            await delay(syncJitter);
         }, stopObj);
 
         const onNodeRemoved = () => {
@@ -219,14 +257,17 @@ class AuthorityLookup {
                 prefixes: prefixes.map(p => parsePrefixMatcher(p)),
                 routeStart: 0,
                 routeEnd: 1,
-                networks: "all",
             }, true);
             return;
         }
 
         let otherPaths = await timeoutToError(
             CALL_TIMEOUT,
-            AuthorityLookupController.nodes[nodeId].networkSyncPaths(this.ourSpec, this.ourIsReady),
+            AuthorityLookupController.nodes[nodeId].networkSyncPaths({
+                spec: this.ourSpec,
+                isReady: this.ourIsReady,
+                scheduledShutdownTime: getScheduledShutdownTime(),
+            }),
             () => new Error(`Timeout calling networkSyncPaths for ${nodeId}`)
         );
         console.info(`Finished network sync`, {
@@ -236,7 +277,7 @@ class AuthorityLookup {
             ourSpec: this.ourSpec,
             ourIsReady: this.ourIsReady,
         });
-        this.updatePaths(nodeId, otherPaths.spec, otherPaths.isReady);
+        this.updatePaths(nodeId, otherPaths.spec, otherPaths.isReady, otherPaths.scheduledShutdownTime);
         this.disconnectWatch(nodeId);
     }
 

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

@@ -8,7 +8,6 @@ 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 { DEFAULT_NETWORK } from "../config";
 import { sha256 } from "js-sha256";
 import { rangesOverlap, removeRange } from "../rangeMath";
 import { decodeParentFilter } from "./hackedPackedPathParentFiltering";
@@ -38,23 +37,8 @@ export type AuthoritySpec = {
     prefixes: PrefixMatcher[];
     //  - Make sure to set this if you just want the prefix values, otherwise you will get all that that prefixes don't match (the prefixes exclude prefix match but where route does not match).
     excludeDefault?: boolean;
-    // The networks this authority satisfies. Unset is equivalent to ["default"]. Paths only route to non-default networks if their routing override key explicitly asks for that network. "all" is ONLY for client proxy specs (the querysub server the client talks to proxies to the real authorities, which do their own network routing), and is not valid for real authorities.
-    networks?: string[] | "all";
 };
 
-function getSpecNetworkList(networks: string[] | undefined): string[] {
-    return networks && networks.length > 0 && networks || [DEFAULT_NETWORK];
-}
-export function specSatisfiesNetwork(spec: AuthoritySpec, network: string | undefined): boolean {
-    if (spec.networks === "all") return true;
-    return getSpecNetworkList(spec.networks).includes(network || DEFAULT_NETWORK);
-}
-export function networksOverlap(spec1: AuthoritySpec, spec2: AuthoritySpec): boolean {
-    if (spec1.networks === "all" || spec2.networks === "all") return true;
-    let networks2 = getSpecNetworkList(spec2.networks);
-    return getSpecNetworkList(spec1.networks).some(x => networks2.includes(x));
-}
-
 // If you want to match just a simple path, use parsePrefixMatcher. It won't match ===, so get the parent if you want that (and then filter the result).
 export type PrefixMatcher = {
     prefix: string;
@@ -158,8 +142,7 @@ export class PathRouter {
         let { path, spec } = config;
         path = hack_stripPackedPath(path);
         let override = getRoutingOverride(path);
-        if (!specSatisfiesNetwork(spec, override?.network)) return -1;
-        if (override && override.route !== undefined) {
+        if (override) {
             if (spec.excludeDefault && !hasPrefixHash({ spec, prefixHash: override.prefixHash })) return -1;
             if (override.route < spec.routeStart || override.route >= spec.routeEnd) return -1;
             return override.route;
@@ -202,7 +185,7 @@ export class PathRouter {
     public static getSingleKeyRoute(key: string): number {
         if (key && this.lastKeyRoute.key === key) return this.lastKeyRoute.route;
         let override = getRoutingOverride(key);
-        if (override && override.route !== undefined) {
+        if (override) {
             this.lastKeyRoute.key = key;
             this.lastKeyRoute.route = override.route;
             return override.route;
@@ -348,7 +331,6 @@ export class PathRouter {
                         prefixes: group.prefixes,
                         routeStart: 0,
                         routeEnd: 1,
-                        networks: ourSpec.networks,
                     }
                 });
                 let routeIndex = Math.floor(route * splitCount);
@@ -392,7 +374,6 @@ export class PathRouter {
 
     @measureFnc
     public static overlapsAuthority(authority1: AuthoritySpec, authority2: AuthoritySpec): boolean {
-        if (!networksOverlap(authority1, authority2)) return false;
         // TODO: This becomes complicated because of exclude default, although I feel like there has to be a way to simplify it? Eh... whatever.
 
         let doRangesOverlap = rangesOverlap({ start: authority1.routeStart, end: authority1.routeEnd }, { start: authority2.routeStart, end: authority2.routeEnd });
@@ -457,7 +438,6 @@ export class PathRouter {
         let { target } = config;
         let allSources = authorityLookup.getTopologySync();
         allSources = allSources.filter(x => !isOwnNodeId(x.nodeId));
-        allSources = allSources.filter(x => networksOverlap(x.authoritySpec, target));
         // THIS is normal during initial server startup
         if (!allSources.length) {
             return [];
@@ -517,7 +497,7 @@ export class PathRouter {
         let preferredNodeIds = new Set(config?.preferredNodeIds ?? []);
         for (let group of cohesiveGroups) {
             shuffle(group, Math.random());
-            sort(group, x => preferredNodeIds.has(x.nodeId) ? -1 : 1);
+            sort(group, x => (authorityLookup.nodeIsShuttingDownSoon(x.nodeId) && 2 || 0) + (preferredNodeIds.has(x.nodeId) && 0 || 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.
@@ -577,12 +557,10 @@ export class PathRouter {
             range: { start: number; end: number };
         }[];
     } {
-        let parentFilter = decodeParentFilter(path);
-        let parentRange = parentFilter || {
+        let parentRange = decodeParentFilter(path) || {
             start: 0,
             end: 1,
         };
-        let parentNetwork = parentFilter?.network;
         path = hack_stripPackedPath(path);
         let preferredNodeIds = new Set(config?.preferredNodeIds ?? []);
 
@@ -591,7 +569,6 @@ export class PathRouter {
         //      - 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.
         // NOTE: The only own nodes flag is actually so we can access this before the topology finishes synchronizing. Because we want to be able to call get child read nodes from path value core for some really basic stuff. It also is what the caller wants, but that's not a good enough reason to add this check. The reason we have this check is because without it, the topology won't have finished synchronizing and startup won't work.
         let allSources = config?.onlyOwnNodes ? [{ nodeId: getOwnNodeId(), authoritySpec: authorityLookup.getOurSpec() }] : authorityLookup.getTopologySync();
-        allSources = allSources.filter(x => specSatisfiesNetwork(x.authoritySpec, parentNetwork));
         // Prefer our own node
         sort(allSources, x => isOwnNodeId(x.nodeId) ? -1 : 1);
 
@@ -603,7 +580,7 @@ export class PathRouter {
         let hasPrefix = allSources.filter(x => x.authoritySpec.prefixes.some(y => isPrefixParent(y, path))).map(x => x.authoritySpec);
         if (hasPrefix.length > 0) {
             shuffle(hasPrefix, Math.random());
-            sort(hasPrefix, x => preferredNodeIds.has(x.nodeId) ? -1 : 1);
+            sort(hasPrefix, x => (authorityLookup.nodeIsShuttingDownSoon(x.nodeId) && 2 || 0) + (preferredNodeIds.has(x.nodeId) && 0 || 1));
 
             let missingRanges: { start: number; end: number }[] = [{
                 ...parentRange
@@ -645,7 +622,7 @@ export class PathRouter {
         });
         if (nestedMatches.length > 0) {
             shuffle(nestedMatches, Math.random());
-            sort(nestedMatches, x => preferredNodeIds.has(x.nodeId) ? -1 : 1);
+            sort(nestedMatches, x => (authorityLookup.nodeIsShuttingDownSoon(x.nodeId) && 2 || 0) + (preferredNodeIds.has(x.nodeId) && 0 || 1));
             sort(allSources, x => isOwnNodeId(x.nodeId) ? -1 : 1);
             return {
                 // Only need to take the first match. 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. 
@@ -664,7 +641,7 @@ export class PathRouter {
         // Same as prefix matches. Not preferred, and not preferred over being under a prefix, but required for some root data, or data with no prefixes.
         if (fullPathMatches.length > 0) {
             shuffle(fullPathMatches, Math.random());
-            sort(fullPathMatches, x => preferredNodeIds.has(x.nodeId) ? -1 : 1);
+            sort(fullPathMatches, x => (authorityLookup.nodeIsShuttingDownSoon(x.nodeId) && 2 || 0) + (preferredNodeIds.has(x.nodeId) && 0 || 1));
             sort(allSources, x => isOwnNodeId(x.nodeId) ? -1 : 1);
             let missingRanges: { start: number; end: number }[] = [{
                 ...parentRange
@@ -697,7 +674,7 @@ export class PathRouter {
         if (!config?.onlyOwnNodes) {
 
             // NOTE: We *could* actually synchronize it even if it doesn't have a prefix shard as we can fall back to just the full path sharding. However, it becomes very complicated if we want a specific range, and then it becomes complicated if it then switches to prefix hashing (With the nodes that were using the full path hashing slowly going away). AND... key synchronization IS slow, so it's good to discourage it in general. 
-            console.error(`Want to sync a prefix which is not under an existing prefix, nor equal to a prefix. 1) The servers are down. 1.5) The servers are in an inconsistent state (one shard range added a parent path, the other didn't). 2) Don't access the .keys() 3) call addRoutingPrefixForDeploy to add a route/parent route explicitly (as is done in PathFunctionRunner.ts). 4) No server is on the network (only servers on the network can satisfy it). Path: ${JSON.stringify(path)}, network: ${parentNetwork || DEFAULT_NETWORK}`, { path, network: parentNetwork || DEFAULT_NETWORK, allSources: allSources.map(x => x.authoritySpec) });
+            console.error(`Want to sync a prefix which is not under an existing prefix, nor equal to a prefix. 1) The servers are down. 1.5) The servers are in an inconsistent state (one shard range added a parent path, the other didn't). 2) Don't access the .keys() 3) call addRoutingPrefixForDeploy to add a route/parent route explicitly (as is done in PathFunctionRunner.ts). Path: ${JSON.stringify(path)}`, { path, allSources: allSources.map(x => x.authoritySpec) });
         }
         return { nodes: [] };
     }
@@ -712,6 +689,8 @@ export class PathRouter {
     public static getReadyAuthority(path: string): AuthorityEntry | undefined {
         let candidates = authorityLookup.getTopologySync();
         shuffle(candidates, Math.random());
+        // Only use nodes that are about to shut down if nothing else matches
+        sort(candidates, x => authorityLookup.nodeIsShuttingDownSoon(x.nodeId) && 1 || 0);
         for (let candidate of candidates) {
             if (!candidate.isReady) continue;
             if (this.matchesAuthoritySpec(candidate.authoritySpec, path)) {

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

@@ -2,7 +2,6 @@ import { cacheLimited } from "socket-function/src/caching";
 import { AuthoritySpec, PathRouter } from "./PathRouter";
 import { sha256 } from "js-sha256";
 import { getPathFromStr } from "../path";
-import { DEFAULT_NETWORK } from "../config";
 
 function getPrefixHash(prefix: string): string {
     return Buffer.from(sha256(prefix), "hex").toString("base64").slice(0, 12);
@@ -17,102 +16,21 @@ let keySpecialIdentifier = (
     + String.fromCharCode(0xF4D7)
 );
 
-export function assertValidNetwork(network: string) {
-    if (!/^[a-z]+$/.test(network)) {
-        throw new Error(`Networks must be lowercase letters (a-z) only, was ${JSON.stringify(network)}`);
-    }
-}
-
-// The route slot is either a route number ("0.12345"), a network ("dev"), or both ("dev:0.12345"). Networks are strictly lowercase letters and routes are strictly numeric, so the forms are unambiguous.
-function encodeRouteSlot(config: { route?: number; network?: string }): string {
-    let { route, network } = config;
-    let routeStr = route !== undefined && route.toString().slice(0, 7) || "";
-    if (network && routeStr) return `${network}:${routeStr}`;
-    if (network) return network;
-    return routeStr;
-}
-function decodeRouteSlot(slot: string): { route?: number; network?: string } | undefined {
-    if (!slot) return undefined;
-    let network: string | undefined;
-    let routeStr = slot;
-    let colonIndex = slot.indexOf(":");
-    if (colonIndex >= 0) {
-        network = slot.slice(0, colonIndex);
-        routeStr = slot.slice(colonIndex + 1);
-    } else if (/^[a-z]+$/.test(slot)) {
-        return { network: slot };
-    }
-    if (network && !/^[a-z]+$/.test(network)) return undefined;
-    let route = parseFloat(routeStr);
-    if (isNaN(route)) return undefined;
-    return { route, network };
-}
-
-export function createRoutingOverrideKeyBase(config: {
-    originalKey: string;
-    // Hashed to get the route, if route is not directly provided
-    routeKey?: string;
-    route?: number;
-    network?: string;
-    // This is the prefix it has the equivalent of. We need this, so if something excludes default, it doesn't automatically get every routing overridden value. Required whenever a route (or routeKey) is set.
-    remappedPrefix?: string;
-}) {
-    let { originalKey, routeKey, route, network, remappedPrefix } = config;
-    if (network) {
-        assertValidNetwork(network);
-    }
-    if (route === undefined && routeKey !== undefined) {
-        route = PathRouter.getSingleKeyRoute(routeKey);
-    }
-    if (route === undefined && !network) {
-        throw new Error(`createRoutingOverrideKeyBase requires at least one of route, routeKey, or network`);
-    }
-    if (route !== undefined && !remappedPrefix) {
-        throw new Error(`createRoutingOverrideKeyBase requires remappedPrefix when a route is set, so excludeDefault authorities can match it correctly`);
-    }
-    let prefixHash = remappedPrefix && getPrefixHash(remappedPrefix) || "";
-    return keySpecialIdentifier + "!" + prefixHash + "!" + encodeRouteSlot({ route, network }) + "!" + originalKey;
-}
-
 export function createRoutingOverrideKey(config: {
     originalKey: string;
     routeKey: string;
+    // This is the prefix it has the equivalent of. We need this, so if something excludes default, it doesn't automatically get every routing overridden value.
     remappedPrefix: string;
-    network?: string;
 }) {
-    return createRoutingOverrideKeyBase(config);
-}
-
-/** Creates a key that routes to a specific network, but otherwise routes normally (via prefix / full path hashing). */
-export function createNetworkKey(config: {
-    originalKey: string;
-    network: string;
-}) {
-    return createRoutingOverrideKeyBase({ originalKey: config.originalKey, network: config.network });
-}
-
-/** Rewrites the routing override part inside key (which must contain one) to be on the given network. */
-export function setRoutingOverrideKeyNetwork(key: string, network: string): string {
-    assertValidNetwork(network);
-    if (!key.startsWith(keySpecialIdentifier)) {
-        return createNetworkKey({ originalKey: key, network });
-    }
-    let parts = key.split("!");
-    if (parts.length < 4) {
-        return createNetworkKey({ originalKey: key, network });
-    }
-    let slot = decodeRouteSlot(parts[2]) || {};
-    parts[2] = encodeRouteSlot({ route: slot.route, network });
-    return parts.join("!");
+    let { originalKey, routeKey, remappedPrefix } = config;
+    let route = PathRouter.getSingleKeyRoute(routeKey);
+    return keySpecialIdentifier + "!" + getPrefixHash(remappedPrefix) + "!" + route.toString().slice(0, 7) + "!" + originalKey;
 }
 
-export type RoutingOverride = {
+export function getRoutingOverride(path: string): {
+    route: number;
     prefixHash: string;
-    route?: number;
-    network?: string;
-};
-
-export function getRoutingOverride(path: string): RoutingOverride | undefined {
+} | undefined {
     if (!path.includes(keySpecialIdentifier)) return undefined;
     let parts = getPathFromStr(path);
     for (let part of parts) {
@@ -121,24 +39,22 @@ export function getRoutingOverride(path: string): RoutingOverride | undefined {
     }
     return undefined;
 }
-export function getRoutingOverridePart(part: string): RoutingOverride | 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 slot = decodeRouteSlot(parts[2]);
-    if (!slot) return undefined;
+    let route = parseFloat(parts[2]);
+    if (isNaN(route)) return undefined;
     return {
         prefixHash,
-        route: slot.route,
-        network: slot.network,
+        route,
     };
 }
 
-export function getPathNetwork(path: string): string {
-    return getRoutingOverride(path)?.network || DEFAULT_NETWORK;
-}
-
 export const hasPrefixHash = cacheLimited(1000 * 10,
     (config: { spec: AuthoritySpec, prefixHash: string }) => {
         let { spec, prefixHash } = config;

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

@@ -1,7 +1,7 @@
 import path from "path";
 import { AuthoritySpec, parsePrefixMatcher } from "./PathRouter";
 import { getPathDepth } from "../path";
-import { getAuthorityRange, getAuthorityExcludeDefault, getAuthorityPrefix, getNetworks } from "../config";
+import { getAuthorityRange, getAuthorityExcludeDefault, getAuthorityPrefix } from "../config";
 import { getShardPrefixes } from "./ShardPrefixes";
 import { getOwnNodeId } from "../-f-node-discovery/NodeDiscovery";
 
@@ -22,7 +22,6 @@ export async function getOurAuthoritySpec(defaultToAll?: boolean): Promise<Autho
                 routeStart: 0,
                 routeEnd: 1,
                 prefixes: prefixMatchers,
-                networks: getNetworks(),
             };
         }
         return undefined;
@@ -47,7 +46,6 @@ export async function getOurAuthoritySpec(defaultToAll?: boolean): Promise<Autho
         routeEnd: rangeEnd,
         prefixes: usePrefixes,
         excludeDefault: excludeDefault || undefined,
-        networks: getNetworks(),
     };
 }
 
@@ -69,6 +67,5 @@ export async function getAllAuthoritySpec(): Promise<AuthoritySpec> {
         routeStart: 0,
         routeEnd: 1,
         prefixes: prefixMatchers,
-        networks: getNetworks(),
     };
 }

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

@@ -20,8 +20,6 @@ import { debugNodeId } from "../-c-identity/IdentityController";
 import { decodeNodeId } from "sliftutils/misc/https/certs";
 import { getDomain } from "../config";
 import { decodeParentFilter, encodeParentFilter } from "./hackedPackedPathParentFiltering";
-import { getPathNetwork } from "./PathRouterRouteOverride";
-import { DEFAULT_NETWORK } from "../config";
 import { deepCloneCborx } from "../misc/cloneHelpers";
 import { removeRange } from "../rangeMath";
 import { registerShutdownHandler } from "../diagnostics/periodic";
@@ -207,9 +205,8 @@ class PathValueCommitter {
                         parentSyncs: [],
                         initialTriggers: { values: new Set(), parentPaths: new Set() },
                     });
-                    console.error(`There are no authorities for path ${pathValue.path} (network ${getPathNetwork(pathValue.path)}). The write will be lost.`, {
+                    console.error(`There are no authorities for path ${pathValue.path}. The write will be lost.`, {
                         path: pathValue.path,
-                        network: getPathNetwork(pathValue.path),
                         timeId: pathValue.time.time,
                         source: pathValue.source,
                         otherAuthorities,
@@ -352,7 +349,6 @@ class PathValueCommitter {
                                     remoteWatcher.getExistingWatchRemoteNodeId(path);
                                     console.warn(`Ignoring value from wrong authority. Should have been ${debugNodeId(watchingAuthorityId)}, but was received from ${debugNodeId(batch.sourceNodeId)}.`, {
                                         path,
-                                        network: getPathNetwork(path),
                                         type,
                                         timeId: value?.time.time,
                                         source: value?.source,
@@ -394,7 +390,6 @@ class PathValueCommitter {
 
                             console.warn(`Ignoring parent path which we aren't watching. From ${debugNodeId(batch.sourceNodeId)}.`, {
                                 parentPath,
-                                network: decodeParentFilter(parentPath)?.network || DEFAULT_NETWORK,
                                 sourceNodeId: debugNodeId(batch.sourceNodeId),
                                 sourceNodeThreadId: decodeNodeId(batch.sourceNodeId, getDomain())?.threadId,
                             });