querysub 0.504.0 → 0.506.0

package/bin/function.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
 process.argv.push("--local");
-// Only dev. If we listen to all functions it will start picking up production functions calls, which breaks things (unlike the path value server, where we are unreachable, so nothing breaks).
-process.argv.push("--filter");
-process.argv.push("dev");
+// Only the dev network. If we listen to all networks it will start picking up production function calls, which breaks things (unlike the path value server, where we are unreachable, so nothing breaks).
+process.argv.push("--networkfile");
+process.argv.push("~/devnetwork.txt");
 
 require("typenode");
 require("../src/3-path-functions/PathFunctionRunnerMain");

package/bin/server-dev.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+
+process.argv.push("--local");
+// Serves the dev network AND the default network, so one server can satisfy paths with no network as well as paths on our dev network.
+process.argv.push("--networkfile");
+process.argv.push("~/devnetwork.txt");
+process.argv.push("--network");
+process.argv.push("default");
+
+require("typenode");
+require("../src/server.ts");

package/bin/server.js

@@ -1,6 +1,8 @@
 #!/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.504.0",
+  "version": "0.506.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
@@ -31,6 +31,7 @@
     "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",

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

@@ -219,6 +219,7 @@ class AuthorityLookup {
                 prefixes: prefixes.map(p => parsePrefixMatcher(p)),
                 routeStart: 0,
                 routeEnd: 1,
+                networks: "all",
             }, true);
             return;
         }

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

@@ -8,6 +8,7 @@ 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";
@@ -37,8 +38,23 @@ 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;
@@ -142,7 +158,8 @@ export class PathRouter {
         let { path, spec } = config;
         path = hack_stripPackedPath(path);
         let override = getRoutingOverride(path);
-        if (override) {
+        if (!specSatisfiesNetwork(spec, override?.network)) return -1;
+        if (override && override.route !== undefined) {
             if (spec.excludeDefault && !hasPrefixHash({ spec, prefixHash: override.prefixHash })) return -1;
             if (override.route < spec.routeStart || override.route >= spec.routeEnd) return -1;
             return override.route;
@@ -185,7 +202,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) {
+        if (override && override.route !== undefined) {
             this.lastKeyRoute.key = key;
             this.lastKeyRoute.route = override.route;
             return override.route;
@@ -331,6 +348,7 @@ export class PathRouter {
                         prefixes: group.prefixes,
                         routeStart: 0,
                         routeEnd: 1,
+                        networks: ourSpec.networks,
                     }
                 });
                 let routeIndex = Math.floor(route * splitCount);
@@ -374,6 +392,7 @@ 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 });
@@ -438,6 +457,7 @@ 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 [];
@@ -557,10 +577,12 @@ export class PathRouter {
             range: { start: number; end: number };
         }[];
     } {
-        let parentRange = decodeParentFilter(path) || {
+        let parentFilter = decodeParentFilter(path);
+        let parentRange = parentFilter || {
             start: 0,
             end: 1,
         };
+        let parentNetwork = parentFilter?.network;
         path = hack_stripPackedPath(path);
         let preferredNodeIds = new Set(config?.preferredNodeIds ?? []);
 
@@ -569,6 +591,7 @@ 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);
 
@@ -674,7 +697,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). Path: ${JSON.stringify(path)}`, { path, 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). 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) });
         }
         return { nodes: [] };
     }

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

@@ -2,13 +2,12 @@ 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);
 }
 
-// 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_"
@@ -18,22 +17,102 @@ let keySpecialIdentifier = (
     + 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 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;
 }) {
-    let { originalKey, routeKey, remappedPrefix } = config;
-    let route = PathRouter.getSingleKeyRoute(routeKey);
-    return keySpecialIdentifier + "!" + getPrefixHash(remappedPrefix) + "!" + route.toString().slice(0, 7) + "!" + originalKey;
+    return createRoutingOverrideKeyBase({ originalKey: config.originalKey, network: config.network });
 }
 
-export function getRoutingOverride(path: string): {
-    route: number;
+/** 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("!");
+}
+
+export type RoutingOverride = {
     prefixHash: string;
-} | undefined {
+    route?: number;
+    network?: string;
+};
+
+export function getRoutingOverride(path: string): RoutingOverride | undefined {
     if (!path.includes(keySpecialIdentifier)) return undefined;
     let parts = getPathFromStr(path);
     for (let part of parts) {
@@ -42,22 +121,24 @@ export function getRoutingOverride(path: string): {
     }
     return undefined;
 }
-export function getRoutingOverridePart(part: string): {
-    prefixHash: string;
-    route: number;
-} | undefined {
+export function getRoutingOverridePart(part: string): RoutingOverride | 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;
+    let slot = decodeRouteSlot(parts[2]);
+    if (!slot) return undefined;
     return {
         prefixHash,
-        route,
+        route: slot.route,
+        network: slot.network,
     };
 }
 
+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;
@@ -69,4 +150,3 @@ export const hasPrefixHash = cacheLimited(1000 * 10,
         return false;
     }
 );
-

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

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

@@ -20,6 +20,8 @@ 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";
@@ -205,8 +207,9 @@ class PathValueCommitter {
                         parentSyncs: [],
                         initialTriggers: { values: new Set(), parentPaths: new Set() },
                     });
-                    console.error(`There are no authorities for path ${pathValue.path}. The write will be lost.`, {
+                    console.error(`There are no authorities for path ${pathValue.path} (network ${getPathNetwork(pathValue.path)}). The write will be lost.`, {
                         path: pathValue.path,
+                        network: getPathNetwork(pathValue.path),
                         timeId: pathValue.time.time,
                         source: pathValue.source,
                         otherAuthorities,
@@ -349,6 +352,7 @@ 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,
@@ -390,6 +394,7 @@ 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,
                             });

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

@@ -9,7 +9,9 @@ import { pathValueSerializer } from "../-h-path-value-serialize/PathValueSeriali
 import { pathValueCommitter } from "./PathValueCommitter";
 import { auditLog, isDebugLogEnabled } from "./auditLogs";
 import { debugNodeId, debugNodeThread } from "../-c-identity/IdentityController";
-import { getSlowdown, isDiskAudit, getDomain } from "../config";
+import { getSlowdown, isDiskAudit, getDomain, DEFAULT_NETWORK } from "../config";
+import { getPathNetwork } from "./PathRouterRouteOverride";
+import { decodeParentFilter } from "./hackedPackedPathParentFiltering";
 import { decodeNodeId } from "sliftutils/misc/https/certs";
 import { areNodeIdsEqual, isOwnNodeId } from "../-f-node-discovery/NodeDiscovery";
 import { getNodeIdIP } from "socket-function/src/nodeCache";
@@ -233,10 +235,10 @@ export class PathValueControllerBase {
         if (isDebugLogEnabled()) {
             let sourceNodeId = debugNodeId(callerId);
             for (let value of config.paths) {
-                auditLog("WATCH PATH", { path: value, sourceNodeId, sourceNodeThreadId: debugNodeThread(callerId) });
+                auditLog("WATCH PATH", { path: value, network: getPathNetwork(value), sourceNodeId, sourceNodeThreadId: debugNodeThread(callerId) });
             }
             for (let value of config.parentPaths) {
-                auditLog("WATCH PARENT PATH", { path: value, sourceNodeId });
+                auditLog("WATCH PARENT PATH", { path: value, network: decodeParentFilter(value)?.network || DEFAULT_NETWORK, sourceNodeId });
             }
         }
         pathWatcher.watchPath({
@@ -252,10 +254,10 @@ export class PathValueControllerBase {
         if (isDebugLogEnabled()) {
             let sourceNodeId = debugNodeId(SocketFunction.getCaller().nodeId);
             for (let value of config.paths) {
-                auditLog("UNWATCHING PATH", { path: value, sourceNodeId, sourceNodeThreadId: debugNodeThread(callerId) });
+                auditLog("UNWATCHING PATH", { path: value, network: getPathNetwork(value), sourceNodeId, sourceNodeThreadId: debugNodeThread(callerId) });
             }
             for (let value of config.parentPaths) {
-                auditLog("UNWATCHING PARENT PATH", { path: value, sourceNodeId });
+                auditLog("UNWATCHING PARENT PATH", { path: value, network: decodeParentFilter(value)?.network || DEFAULT_NETWORK, sourceNodeId });
             }
         }
         pathWatcher.unwatchPath({ paths: config.paths, parentPaths: config.parentPaths, callback: callerId, reason: "PathValueController.unwatchLatest" });

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

@@ -11,7 +11,9 @@ import { PathValueControllerBase } from "./PathValueController";
 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 { decodeParentFilter, matchesParentRangeFilter } from "./hackedPackedPathParentFiltering";
+import { getPathNetwork } from "./PathRouterRouteOverride";
+import { DEFAULT_NETWORK } from "../config";
 import { isClient } from "../config2";
 import { delay } from "socket-function/src/batching";
 import { isClientNodeId } from "socket-function/src/nodeCache";
@@ -170,21 +172,22 @@ class PathWatcher {
             incrementWatcherSequence();
             if (isOwnNodeId(config.nodeId)) {
                 for (let path of newPathsWatched) {
-                    auditLog("new local WATCH VALUE", { path });
+                    auditLog("new local WATCH VALUE", { path, network: getPathNetwork(path) });
                 }
                 for (let path of newParentsWatched) {
-                    auditLog("new local WATCH PARENT", { path });
+                    auditLog("new local WATCH PARENT", { path, network: decodeParentFilter(path)?.network || DEFAULT_NETWORK });
                 }
             } else {
                 for (let path of newPathsWatched) {
                     auditLog("new non-local WATCH VALUE", {
                         path,
+                        network: getPathNetwork(path),
                         watcher: config.nodeId,
                         sourceNodeThreadId: debugNodeThread(config.nodeId),
                     });
                 }
                 for (let path of newParentsWatched) {
-                    auditLog("new non-local WATCH PARENT", { path, watcher: config.nodeId });
+                    auditLog("new non-local WATCH PARENT", { path, network: decodeParentFilter(path)?.network || DEFAULT_NETWORK, watcher: config.nodeId });
                 }
             }
             console.info(`New PathValue watches`, {
@@ -244,9 +247,9 @@ class PathWatcher {
             obj.watchers.delete(callback);
 
             if (isOwnNodeId(callback)) {
-                auditLog("local UNWATCH PARENT", { path, reason });
+                auditLog("local UNWATCH PARENT", { path, network: decodeParentFilter(path)?.network || DEFAULT_NETWORK, reason });
             } else {
-                auditLog("non-local UNWATCH PARENT", { path, watcher: callback, remoteNodeId: debugNodeId(callback), remoteNodeThreadId: debugNodeThread(callback), reason });
+                auditLog("non-local UNWATCH PARENT", { path, network: decodeParentFilter(path)?.network || DEFAULT_NETWORK, watcher: callback, remoteNodeId: debugNodeId(callback), remoteNodeThreadId: debugNodeThread(callback), reason });
             }
 
             if (obj.watchers.size === 0) {
@@ -281,9 +284,9 @@ class PathWatcher {
             watchers.watchers.delete(callback);
 
             if (isOwnNodeId(callback)) {
-                auditLog("local UNWATCH VALUE", { path, reason });
+                auditLog("local UNWATCH VALUE", { path, network: getPathNetwork(path), reason });
             } else {
-                auditLog("non-local UNWATCH VALUE", { path, watcher: callback, reason });
+                auditLog("non-local UNWATCH VALUE", { path, network: getPathNetwork(path), watcher: callback, reason });
             }
 
             if (watchers.watchers.size === 0) {

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

@@ -3,6 +3,8 @@ import { getPathDepth, getPathIndexAssert, hack_getPackedPathSuffix, hack_setPac
 import { AuthoritySpec, PathRouter } from "./PathRouter";
 import { cache } from "socket-function/src/caching";
 import { authorityLookup } from "./AuthorityLookup";
+import { assertValidNetwork, getPathNetwork } from "./PathRouterRouteOverride";
+import { DEFAULT_NETWORK } from "../config";
 
 
 let getSpecForChildPath = (path: string) => authorityLookup.getOurSpec();
@@ -15,10 +17,15 @@ export function matchesParentRangeFilter(config: {
     fullPath: string;
     packedPath: string;
 }) {
-    // If it equals the non packed path, then it must not be packed, and so it must match. 
-    if (config.parentPath === config.packedPath) return true;
+    // If it equals the non packed path, then it must not be packed, and so it must match.
+    if (config.parentPath === config.packedPath) {
+        return getPathNetwork(config.fullPath) === DEFAULT_NETWORK;
+    }
     let filter = decodeParentFilter(config.packedPath);
-    if (!filter) return true;
+    if (!filter) {
+        return getPathNetwork(config.fullPath) === DEFAULT_NETWORK;
+    }
+    if (getPathNetwork(config.fullPath) !== (filter.network || DEFAULT_NETWORK)) return false;
     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;
@@ -26,12 +33,14 @@ export function matchesParentRangeFilter(config: {
 
 export const filterChildPathsBase = measureWrap(
     function filterChildPathsBase(parentPath: string, packedSuffix: string, paths: Set<string>): Set<string> {
-        let [startFractionStr, endFractionStr] = packedSuffix.split("|");
+        let [startFractionStr, endFractionStr, network] = packedSuffix.split("|");
         let startFraction = Number(startFractionStr);
         let endFraction = Number(endFractionStr);
+        let filterNetwork = network || DEFAULT_NETWORK;
 
         let filtered = new Set<string>();
         for (let path of paths) {
+            if (getPathNetwork(path) !== filterNetwork) continue;
             // 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) {
@@ -47,14 +56,19 @@ export function encodeParentFilter(config: {
     path: string;
     startFraction: number;
     endFraction: number;
+    network?: string;
 }) {
-    return hack_setPackedPathSuffix(config.path, `${config.startFraction}|${config.endFraction}`);
+    let suffix = `${config.startFraction}|${config.endFraction}`;
+    if (config.network) {
+        assertValidNetwork(config.network);
+        suffix += `|${config.network}`;
+    }
+    return hack_setPackedPathSuffix(config.path, suffix);
 }
-export function decodeParentFilter(path: string): { path: string; start: number, end: number } | undefined {
+export function decodeParentFilter(path: string): { path: string; start: number, end: number; network?: string } | undefined {
     let packedSuffix = hack_getPackedPathSuffix(path);
     if (!packedSuffix) return undefined;
-    let [startStr, endStr] = packedSuffix.split("|");
+    let [startStr, endStr, network] = packedSuffix.split("|");
     let unpackedPath = hack_stripPackedPath(path);
-    return { path: unpackedPath, start: Number(startStr), end: Number(endStr) };
-
-}
+    return { path: unpackedPath, start: Number(startStr), end: Number(endStr), network: network || undefined };
+}

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

@@ -24,7 +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 { getPathNetwork } from "./PathRouterRouteOverride";
+import { isDiskAudit, DEFAULT_NETWORK } from "../config";
 import { removeRange } from "../rangeMath";
 import { remoteWatcher } from "../1-path-client/RemoteWatcher";
 import { setFlag } from "socket-function/require/compileFlags";
@@ -569,18 +570,20 @@ class AuthorityPathValueStorage {
         if (this.DEBUG_UNWATCH) {
             console.log(blue(`Unsyncing path at ${Date.now()}`), path);
         }
-        auditLog("DESTROY PATH", { path });
+        auditLog("DESTROY PATH", { path, network: getPathNetwork(path) });
 
         this.isSyncedCache.delete(path);
         this.removePathFromStorage(path, "unwatched");
     }
     public markParentPathAsUnwatched(path: string) {
         if (this.parentsSynced.has(path)) {
-            console.info(`Unwatching path that is a parent synced path (fine, but might be an issue)`, { path });
+            console.info(`Unwatching path that is a parent synced path (fine, but might be an issue)`, { path, network: decodeParentFilter(path)?.network || DEFAULT_NETWORK });
         }
         // NOTE: I don't think we have to handle the case where we are the authority,
         //  because we don't delete any actual data here.
         this.parentsSynced.delete(path);
+        let decoded = decodeParentFilter(path);
+        this.parentsSynced.delete(this.parentSyncKey(hack_stripPackedPath(path), decoded?.network));
     }
 
     /** Used for atomic operations, to ensure a path is stable enough (and to check that it hasn't
@@ -607,6 +610,11 @@ class AuthorityPathValueStorage {
         }
         return true;
     }
+    private parentSyncKey(strippedParentPath: string, network: string | undefined): string {
+        if (!network || network === DEFAULT_NETWORK) return strippedParentPath;
+        return strippedParentPath + String.fromCharCode(1) + "network=" + network;
+    }
+
     public isSynced(path: string) {
         if (PathRouter.isSelfAuthority(path)) return true;
 
@@ -635,7 +643,7 @@ class AuthorityPathValueStorage {
         let remoteWatchRoute = remoteWatcher.getRemoteParentWatchRoute(path);
         if (remoteWatchRoute !== undefined) {
             let parent = getParentPathStr(path);
-            let ranges = this.parentsSynced.get(parent);
+            let ranges = this.parentsSynced.get(this.parentSyncKey(parent, getPathNetwork(path)));
             // NOTE: We can't cache this because when we stop watching the parent, the remote watch will remove it, which will cause us to be no longer synced. However, it's not going to know to go into our synced cache and remove it. 
             if (ranges === true) return true;
             if (ranges) {
@@ -657,7 +665,7 @@ class AuthorityPathValueStorage {
         parentPath = hack_stripPackedPath(parentPath);
         if (PathRouter.isLocalPath(parentPath)) return true;
 
-        let synced = this.parentsSynced.get(originalPath) || this.parentsSynced.get(parentPath);
+        let synced = this.parentsSynced.get(originalPath) || this.parentsSynced.get(this.parentSyncKey(parentPath, range?.network));
         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) {
@@ -694,12 +702,12 @@ class AuthorityPathValueStorage {
     public addParentSyncs(parentSyncs: { parentPath: string; sourceNodeId: string }[]) {
         for (let obj of parentSyncs) {
             if (isDebugLogEnabled()) {
-                auditLog("RECEIVED PARENT PATH", { parentPath: obj.parentPath, remoteNodeId: debugNodeId(obj.sourceNodeId), remoteNodeThreadId: debugNodeThread(obj.sourceNodeId) });
+                auditLog("RECEIVED PARENT PATH", { parentPath: obj.parentPath, network: decodeParentFilter(obj.parentPath)?.network || DEFAULT_NETWORK, remoteNodeId: debugNodeId(obj.sourceNodeId), remoteNodeThreadId: debugNodeThread(obj.sourceNodeId) });
             }
 
             let decoded = decodeParentFilter(obj.parentPath);
             let range = decoded ? { start: decoded.start, end: decoded.end } : { start: 0, end: 1 };
-            let parentPath = hack_stripPackedPath(obj.parentPath);
+            let parentPath = this.parentSyncKey(hack_stripPackedPath(obj.parentPath), decoded?.network);
 
             let prevSynced = this.parentsSynced.get(parentPath);
             if (prevSynced === true) continue;