querysub 0.524.0 → 0.526.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.524.0",
+  "version": "0.526.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
@@ -70,7 +70,7 @@
     "pako": "^2.1.0",
     "peggy": "^5.0.6",
     "sliftutils": "^1.7.5",
-    "socket-function": "^1.2.12",
+    "socket-function": "^1.2.14",
     "terser": "^5.31.0",
     "typenode": "^6.6.1",
     "typesafecss": "^0.32.0",

package/src/-c-identity/IdentityController.ts

@@ -19,7 +19,7 @@ import { waitForFirstTimeSync } from "socket-function/time/trueTimeShim";
 import { red } from "socket-function/src/formatting/logColors";
 import { isNode } from "typesafecss";
 import { areNodeIdsEqual, getOwnNodeId, getOwnThreadId } from "../-f-node-discovery/NodeDiscovery";
-import { timeInMinute } from "socket-function/src/misc";
+import { timeInMinute, isIpDomain } from "socket-function/src/misc";
 import { isClient, isServer } from "../config2";
 import { getDomain } from "../config";
 
@@ -242,7 +242,7 @@ const changeIdentityOnce = cacheWeak(async function changeIdentityOnce(connectio
         certIssuer: issuer.cert.toString(),
         mountedPort: getNodeIdLocation(SocketFunction.mountedNodeId)?.port,
         debugEntryPoint: isServer() ? process.argv[1] : "browser",
-        clientIsNode: isServer(),
+        clientIsNode: isServer() && !isIpDomain(nodeId),
     };
     let signature = sign(threadKeyCert, payload);
     await timeoutToError(

package/src/-d-trust/NetworkTrust2.ts

@@ -111,7 +111,7 @@ export async function isNodeTrusted(nodeId: string) {
     return await isTrusted(machineId);
 }
 
-const loadServerCert = cache(async (machineId: string) => {
+export const loadServerCert = cache(async (machineId: string) => {
     // This cert isn't stored in the archives, but... this is fine?
     if (machineId === "127-0-0-1." + getDomain()) return;
     let certFile = await archives().get(machineId);
@@ -131,7 +131,7 @@ export const ensureWeAreTrusted = lazy(measureWrap(async () => {
     }
 }));
 
-async function loadTrustCerts(nodeId: string) {
+export async function loadTrustCerts(nodeId: string) {
     let location = getNodeIdLocation(nodeId);
     if (location) {
         let machineId = getMachineId(location.address, getDomain());

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

@@ -8,7 +8,7 @@
 */
 
 import { SocketFunction } from "socket-function/SocketFunction";
-import { timeInMinute, timeInSecond } from "socket-function/src/misc";
+import { sort, timeInMinute, timeInSecond } from "socket-function/src/misc";
 import { lazy } from "socket-function/src/caching";
 import { delay, runInfinitePollCallAtStart } from "socket-function/src/batching";
 import { isServer } from "../config2";
@@ -23,6 +23,8 @@ const LATENCY_POLL_INTERVAL = timeInMinute;
 const PING_TIMEOUT = timeInSecond * 5;
 // Rolling average size. Small, so latency changes show up quickly.
 const LATENCY_SAMPLE_LIMIT = 20;
+// Raw sample history kept per node, so callers can ask for a median over the last N with a known confidence.
+const LATENCY_HISTORY_LIMIT = 100;
 // Forget nodes we haven't been able to reach for this long.
 const NODE_EXPIRY_TIME = LATENCY_POLL_INTERVAL * 5;
 
@@ -30,6 +32,7 @@ export type NodeLatencyInfo = {
     averageLatency: number;
     sampleCount: number;
     lastSeen: number;
+    history: number[];
 };
 
 // otherNodeId => our rolling latency to it
@@ -42,6 +45,18 @@ export function getNodeLatencyInfo(nodeId: string): NodeLatencyInfo | undefined
 export function getNodeLatency(nodeId: string): number | undefined {
     return getNodeLatencyInfo(nodeId)?.averageLatency;
 }
+// Median of the last historyCount raw samples, plus how many samples were actually available — so callers can scale how much they trust the number.
+export function getNodeLatencyMedian(config: { nodeId: string; historyCount: number }): { latency: number; historyUsed: number } | undefined {
+    let history = getNodeLatencyInfo(config.nodeId)?.history;
+    if (!history || history.length === 0) return undefined;
+    let samples = history.slice(-config.historyCount);
+    sort(samples, x => x);
+    return { latency: samples[Math.floor(samples.length / 2)], historyUsed: samples.length };
+}
+
+export function getCachedNodeLatencyInfoList(): Map<string, NodeLatencyInfo> {
+    return latencyByNode;
+}
 
 /** Our measured latency to every node we have reached, as a plain map (for sending over the wire). */
 export function getOwnLatencies(): { [nodeId: string]: number } {
@@ -56,10 +71,16 @@ export function getOwnLatencies(): { [nodeId: string]: number } {
 function recordLatency(nodeId: string, latency: number) {
     let prev = latencyByNode.get(nodeId);
     let sampleCount = Math.min(prev?.sampleCount || 0, LATENCY_SAMPLE_LIMIT);
+    let history = prev?.history || [];
+    history.push(latency);
+    if (history.length > LATENCY_HISTORY_LIMIT) {
+        history.shift();
+    }
     latencyByNode.set(nodeId, {
         averageLatency: ((prev?.averageLatency || 0) * sampleCount + latency) / (sampleCount + 1),
         sampleCount: sampleCount + 1,
         lastSeen: Date.now(),
+        history,
     });
 }
 
@@ -72,9 +93,11 @@ async function pingNode(nodeId: string) {
     recordLatency(nodeId, Date.now() - start);
 }
 
+let firstCall = true;
 async function pollLatencies() {
     let nodeIds = (await getAllNodeIds()).filter(nodeId => !isOwnNodeId(nodeId));
-    await spreadCallsOverTime(nodeIds, LATENCY_POLL_INTERVAL, pingNode);
+    let spread = firstCall ? 0 : LATENCY_POLL_INTERVAL;
+    await spreadCallsOverTime(nodeIds, spread, pingNode);
 
     let now = Date.now();
     for (let [nodeId, info] of Array.from(latencyByNode)) {
@@ -82,6 +105,7 @@ async function pollLatencies() {
             latencyByNode.delete(nodeId);
         }
     }
+    firstCall = false;
 }
 
 export const startLatencyTracking = lazy(async () => {

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

@@ -26,14 +26,14 @@ const BUCKET_HISTORY = BUCKET_SIZE * 20;
 // not O(client connections) — clients churn through many raw ids per hour and we never want a bucket per client.
 const OUTSIDE_KEY = "";
 
-export type NodeDataTraffic = { sent: number; received: number; };
+export type NodeDataTraffic = { sent: number; received: number; pathValuesSent: number; pathValuesReceived: number; };
 // All numbers are PER-SECOND rates (see file header).
 export type TrafficStats = {
     functionsExecuted: number;
     pathValuesSent: number;
     pathValuesReceived: number;
     querysubCalls: number;
-    // Byte rates to/from each known network node, plus one aggregate for everything outside the node list.
+    // Byte and path value rates to/from each known network node, plus one aggregate for everything outside the node list.
     perNode: { [nodeId: string]: NodeDataTraffic };
     outside: NodeDataTraffic;
 };
@@ -48,6 +48,8 @@ let querysubCalls: BucketMap = new Map();
 // raw connection nodeId => buckets
 let bytesSent = new Map<string, BucketMap>();
 let bytesReceived = new Map<string, BucketMap>();
+let pathValuesSentPerNode = new Map<string, BucketMap>();
+let pathValuesReceivedPerNode = new Map<string, BucketMap>();
 
 function addSimple(buckets: BucketMap, amount: number) {
     let bucket = Math.floor(Date.now() / BUCKET_SIZE) * BUCKET_SIZE;
@@ -65,13 +67,15 @@ function addKeyed(map: Map<string, BucketMap>, key: string, amount: number) {
 export function recordFunctionExecuted() {
     addSimple(functionsExecuted, 1);
 }
-export function recordPathValuesSent(count: number) {
-    if (count <= 0) return;
-    addSimple(pathValuesSent, count);
+export function recordPathValuesSent(config: { count: number; nodeId: string }) {
+    if (config.count <= 0) return;
+    addSimple(pathValuesSent, config.count);
+    addKeyed(pathValuesSentPerNode, trafficKey(config.nodeId), config.count);
 }
-export function recordPathValuesReceived(count: number) {
-    if (count <= 0) return;
-    addSimple(pathValuesReceived, count);
+export function recordPathValuesReceived(config: { count: number; nodeId: string }) {
+    if (config.count <= 0) return;
+    addSimple(pathValuesReceived, config.count);
+    addKeyed(pathValuesReceivedPerNode, trafficKey(config.nodeId), config.count);
 }
 export function recordQuerysubCall() {
     addSimple(querysubCalls, 1);
@@ -111,10 +115,10 @@ function bucketRate(buckets: BucketMap, windowSize: number): number {
 function aggregateData(windowSize: number): { perNode: { [nodeId: string]: NodeDataTraffic }; outside: NodeDataTraffic; } {
     let known = new Set(getCachedNodeIds());
     let perNode: { [nodeId: string]: NodeDataTraffic } = {};
-    let outside: NodeDataTraffic = { sent: 0, received: 0 };
+    let outside: NodeDataTraffic = { sent: 0, received: 0, pathValuesSent: 0, pathValuesReceived: 0 };
     // At most (node count + 1) keys, so this whole pass is O(nodes). debugNodeId (a linear lookup) is only used for
     // the rare server-style id that isn't already a known node.
-    let attribute = (rawNodeId: string, field: "sent" | "received", rate: number) => {
+    let attribute = (rawNodeId: string, field: keyof NodeDataTraffic, rate: number) => {
         if (rate <= 0) return;
         if (rawNodeId === OUTSIDE_KEY) {
             outside[field] += rate;
@@ -124,7 +128,7 @@ function aggregateData(windowSize: number): { perNode: { [nodeId: string]: NodeD
         if (known.has(nice)) {
             let entry = perNode[nice];
             if (!entry) {
-                entry = { sent: 0, received: 0 };
+                entry = { sent: 0, received: 0, pathValuesSent: 0, pathValuesReceived: 0 };
                 perNode[nice] = entry;
             }
             entry[field] += rate;
@@ -132,14 +136,16 @@ function aggregateData(windowSize: number): { perNode: { [nodeId: string]: NodeD
             outside[field] += rate;
         }
     };
-    for (let [rawNodeId, buckets] of Array.from(bytesSent)) {
-        attribute(rawNodeId, "sent", bucketRate(buckets, windowSize));
-        if (buckets.size === 0) bytesSent.delete(rawNodeId);
-    }
-    for (let [rawNodeId, buckets] of Array.from(bytesReceived)) {
-        attribute(rawNodeId, "received", bucketRate(buckets, windowSize));
-        if (buckets.size === 0) bytesReceived.delete(rawNodeId);
-    }
+    let aggregateMap = (map: Map<string, BucketMap>, field: keyof NodeDataTraffic) => {
+        for (let [rawNodeId, buckets] of Array.from(map)) {
+            attribute(rawNodeId, field, bucketRate(buckets, windowSize));
+            if (buckets.size === 0) map.delete(rawNodeId);
+        }
+    };
+    aggregateMap(bytesSent, "sent");
+    aggregateMap(bytesReceived, "received");
+    aggregateMap(pathValuesSentPerNode, "pathValuesSent");
+    aggregateMap(pathValuesReceivedPerNode, "pathValuesReceived");
     return { perNode, outside };
 }
 

package/src/-h-path-value-serialize/PathValueSerializer.ts

@@ -20,7 +20,7 @@ import { formatNumber, formatPercent, formatTime } from "socket-function/src/for
 setFlag(require, "cbor-x", "allowclient", true);
 
 import * as pako from "pako";
-import { delay } from "socket-function/src/batching";
+import { delay, safeLoop } from "socket-function/src/batching";
 import { LZ4 } from "../storage/LZ4";
 import { unblockLoop } from "socket-function/src/batching";
 setFlag(require, "pako", "allowclient", true);
@@ -345,6 +345,7 @@ class PathValueSerializer {
         let encodedValues: (Buffer | number)[] = [];
 
         let i = 0;
+        let valuesSinceYield = 0;
         for (let values of valuesGroups) {
             measureBlock(() => {
                 // NOTE: Writing one value at a time is about 1.6X slower. BUT, it allows us to very efficient decode
@@ -378,21 +379,23 @@ class PathValueSerializer {
                     i++;
                 }
             }, "valuesWriteLoop");
-            await delay("paintLoop");
+            valuesSinceYield += values.length;
+            if (valuesSinceYield >= 10_000) {
+                valuesSinceYield = 0;
+                await delay("paintLoop");
+            }
         }
 
         measureBlock(function valuesWriteTypesBuffer() {
             writer.writeBuffer(types);
         });
-        // Break encodeValues into groups of 100, so we can check the time and delay
-        //      if we are taking too long, but not check it EVERY loop, as that would
-        //      be too slow.
+        // Break encodeValues into groups, and yield based on the amount of values written — NOT by measuring time, as timing every loop is itself too slow.
         let valueGroups: (Buffer | number)[][] = [];
         const VALUE_GROUP_SIZE = 1000;
         for (let i = 0; i < encodedValues.length; i += VALUE_GROUP_SIZE) {
             valueGroups.push(encodedValues.slice(i, i + VALUE_GROUP_SIZE));
         }
-        let prevTime = Date.now();
+        let encodedSinceYield = 0;
         for (let encodedValues of valueGroups) {
             measureBlock(function valuesWriteTypes() {
                 for (let value of encodedValues) {
@@ -403,10 +406,10 @@ class PathValueSerializer {
                     }
                 }
             });
-            let now = Date.now();
-            if (now - prevTime > 10) {
+            encodedSinceYield += encodedValues.length;
+            if (encodedSinceYield >= 10_000) {
+                encodedSinceYield = 0;
                 await delay("paintLoop");
-                prevTime = now;
             }
         }
     }
@@ -550,9 +553,14 @@ class PathValueSerializer {
         }
 
         startNewBuffer("pathValues");
+        let pathValuesSinceYield = 0;
         for (let values of valueGroups) {
             this.pathValuesWrite(writer, values, settings);
-            await delay("afterPaint");
+            pathValuesSinceYield += values.length;
+            if (pathValuesSinceYield >= 10_000) {
+                pathValuesSinceYield = 0;
+                await delay("afterPaint");
+            }
         }
 
         if (!settings.noLocks) {
@@ -593,15 +601,20 @@ class PathValueSerializer {
             curCount += str.length;
         }
 
+        let stringBytesSinceYield = 0;
         for (let strings of stringParts) {
             let stringBuffer = StringSerialize.serializeStrings(strings);
             settings.bufferMap!.push("strings");
             outputBuffers.push(stringBuffer);
-            await delay("paintLoop");
+            stringBytesSinceYield += stringBuffer.length;
+            if (stringBytesSinceYield >= 1_000_000) {
+                stringBytesSinceYield = 0;
+                await delay("paintLoop");
+            }
         }
 
         if (settings.compression === "lz4") {
-            let compressedBuffers = await unblockLoop(outputBuffers, x => LZ4.compress(x));
+            let compressedBuffers = await measureBlock(() => safeLoop({ data: outputBuffers, name: "PathValueSerializer.serialize|lz4" }, x => LZ4.compress(x)), "PathValueSerializer.serialize|lz4");
 
             // If the compress factor is less than a threshold, use the uncompressed buffers
             let uncompressedSize = outputBuffers.reduce((total, x) => total + x.length, 0);
@@ -723,6 +736,7 @@ class PathValueSerializer {
         }
         if (!config?.skipStrings) {
             let stringArrays: string[][] = [];
+            let bytesSinceYield = 0;
             for (let stringBuffer of stringBuffers) {
                 let obj = StringSerialize.deserializeStringsLazy(stringBuffer);
                 while (true) {
@@ -731,11 +745,14 @@ class PathValueSerializer {
                         break;
                     }
                     stringArrays.push(nextStrings);
-                    if (stringArrays.length > 1) {
+                    // Each getNextStrings call decodes ~1MB, so on buffers past that we yield per chunk decoded.
+                    if (stringBuffer.length > 1_000_000) {
                         await delay("paintLoop");
                     }
                 }
-                if (stringBuffers.length > 1) {
+                bytesSinceYield += stringBuffer.length;
+                if (bytesSinceYield >= 1_000_000) {
+                    bytesSinceYield = 0;
                     await delay("paintLoop");
                 }
             }
@@ -848,6 +865,7 @@ class PathValueSerializer {
             }
 
             let stringArrays: string[][] = [];
+            let bytesSinceYield = 0;
             for (let bufferIndex of stringBufferIndexes) {
                 let stringBuffer = buffers[bufferIndex];
                 let obj = StringSerialize.deserializeStringsLazy(stringBuffer);
@@ -857,13 +875,12 @@ class PathValueSerializer {
                         break;
                     }
                     stringArrays.push(nextStrings);
-                    if (stringArrays.length > 1) {
+                    bytesSinceYield += stringBuffer.length;
+                    if (bytesSinceYield >= 1_000_000) {
+                        bytesSinceYield = 0;
                         await delay("paintLoop");
                     }
                 }
-                if (stringBufferIndexes.length > 1) {
-                    await delay("paintLoop");
-                }
             }
             strings = stringArrays.flat();
         }

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

@@ -1,4 +1,4 @@
-import { timeInMinute, timeInSecond } from "socket-function/src/misc";
+import { sort, timeInMinute, timeInSecond } from "socket-function/src/misc";
 import { nestArchives } from "../-a-archives/archives";
 import { getArchivesBackblaze } from "../-a-archives/archivesBackBlaze";
 import { archiveJSONT } from "../-a-archives/archivesJSONT";
@@ -31,7 +31,7 @@ let CALL_TIMEOUT = timeInSecond * 5;
 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;
+const SHUTDOWN_AVOID_WINDOW = timeInMinute * 5;
 
 export type AuthorityEntry = {
     nodeId: string;
@@ -82,6 +82,8 @@ class AuthorityLookup {
     public async setOurSpec(spec: AuthoritySpec) {
         if (!SocketFunction.isMounted()) throw new Error("Cannot call setOurPaths without mounting first (use Querysub.hostService).");
         spec.nodeId = getOwnNodeId();
+        // AuthoritySpec.prefixes promises to be sorted, and this is the choke point every published spec goes through.
+        sort(spec.prefixes, prefix => prefix.originalPrefix);
 
 
         if (this.setSpec) {

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

@@ -5,7 +5,7 @@ import { PathValue } from "./pathValueCore";
 import { shuffle } from "../misc/random";
 import { fastHash } from "../misc/hash";
 import { getOwnNodeId, isOwnNodeId } from "../-f-node-discovery/NodeDiscovery";
-import { getNodeLatency } from "../-f-node-discovery/LatencyTracking";
+import { getNodeLatencyMedian } from "../-f-node-discovery/LatencyTracking";
 import { unique } from "../misc";
 import { measureFnc } from "socket-function/src/profiling/measure";
 import { getRoutingOverride, hasPrefixHash } from "./PathRouterRouteOverride";
@@ -22,12 +22,18 @@ export { LOCAL_DOMAIN, LOCAL_DOMAIN_PATH };
 // fine (two nearby servers just talk to each other). Replaces the old uniform-random pick between candidates.
 const LATENCY_CANDIDATE_LIMIT = 5;
 const LATENCY_WEIGHT_OFFSET = 10;
+// How many latency samples we use per node (median of the last N). The more we actually got, the more we trust the number, and the more aggressively we cut slow candidates.
+const LATENCY_HISTORY_COUNT = 10;
+// A candidate whose weight is below (the current max weight / (this - its historyUsed)) is dropped to zero probability. So with full history the factor is 2 (2x the effective latency of the best is never picked), and with a single sample it is 11 (only extreme outliers are cut).
+const LATENCY_CUTOFF_BASE_FACTOR = 12;
 // Latency assumed for a node we haven't measured yet, so new/unreached nodes stay eligible but aren't preferred.
 const UNKNOWN_LATENCY_MS = 50;
 
-function getRoutingLatency(nodeId: string): number {
-    if (isOwnNodeId(nodeId)) return 0;
-    return getNodeLatency(nodeId) ?? UNKNOWN_LATENCY_MS;
+function getRoutingLatency(nodeId: string): { latency: number; historyUsed: number } {
+    if (isOwnNodeId(nodeId)) return { latency: 0, historyUsed: LATENCY_HISTORY_COUNT };
+    let median = getNodeLatencyMedian({ nodeId, historyCount: LATENCY_HISTORY_COUNT });
+    if (!median) return { latency: UNKNOWN_LATENCY_MS, historyUsed: 0 };
+    return median;
 }
 
 // In-place reorder of candidates by a latency-weighted random draw over the lowest LATENCY_CANDIDATE_LIMIT
@@ -36,20 +42,31 @@ function getRoutingLatency(nodeId: string): number {
 //       since an overloaded server's latency spikes, which already makes it less likely to be chosen here.
 function latencyWeightedShuffle<T extends { nodeId: string }>(arr: T[]) {
     if (arr.length <= 1) return;
-    let withLatency = arr.map(x => ({ x, latency: getRoutingLatency(x.nodeId) }));
+    let withLatency = arr.map(x => {
+        let routingLatency = getRoutingLatency(x.nodeId);
+        return { x, latency: routingLatency.latency, historyUsed: routingLatency.historyUsed };
+    });
     sort(withLatency, e => e.latency);
     let pool = withLatency.slice(0, LATENCY_CANDIDATE_LIMIT);
     let rest = withLatency.slice(LATENCY_CANDIDATE_LIMIT);
     let ordered: T[] = [];
     while (pool.length > 0) {
+        let weights = pool.map(e => 1 / (e.latency + LATENCY_WEIGHT_OFFSET));
+        let maxWeight = Math.max(...weights);
+        for (let i = 0; i < weights.length; i++) {
+            let cutoffFactor = LATENCY_CUTOFF_BASE_FACTOR - Math.min(pool[i].historyUsed, LATENCY_HISTORY_COUNT);
+            if (weights[i] < maxWeight / cutoffFactor) {
+                weights[i] = 0;
+            }
+        }
         let total = 0;
-        for (let e of pool) {
-            total += 1 / (e.latency + LATENCY_WEIGHT_OFFSET);
+        for (let w of weights) {
+            total += w;
         }
         let r = Math.random() * total;
         let idx = 0;
         while (idx < pool.length - 1) {
-            r -= 1 / (pool[idx].latency + LATENCY_WEIGHT_OFFSET);
+            r -= weights[idx];
             if (r <= 0) break;
             idx++;
         }
@@ -82,6 +99,7 @@ export type AuthoritySpec = {
     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.
+    //  - Sorted by originalPrefix (authorityLookup.setOurSpec sorts before publishing), so specs can be compared element-wise.
     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;
@@ -154,6 +172,18 @@ export function parsePrefixMatcher(prefixPath: string): PrefixMatcher {
     };
 }
 
+// Full-overlap equivalence: same range, same default matching, and the same prefixes (prefixes are sorted, so element-wise comparison works).
+export function areAuthoritySpecsEquivalent(a: AuthoritySpec, b: AuthoritySpec): boolean {
+    if (a.routeStart !== b.routeStart) return false;
+    if (a.routeEnd !== b.routeEnd) return false;
+    if (!a.excludeDefault !== !b.excludeDefault) return false;
+    if (a.prefixes.length !== b.prefixes.length) return false;
+    for (let [i, prefix] of a.prefixes.entries()) {
+        if (prefix.originalPrefix !== b.prefixes[i].originalPrefix) return false;
+    }
+    return true;
+}
+
 export function debugSpec(spec: AuthoritySpec) {
     return {
         info: `${spec.routeStart}-${spec.routeEnd} (${spec.prefixes.length} prefixes${spec.excludeDefault ? " excluding default" : ""})`,

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

@@ -144,7 +144,7 @@ class PathValueCommitter {
     }
 
     private broadcastValues = batchFunction(
-        { delay: 10, throttleWindow: 500, noMeasure: true },
+        { delay: 1, throttleWindow: 2000, noMeasure: true },
         async function internal_forwardWrites(valuesBatched: {
             values: Set<PathValue>;
             tryCount?: number;
@@ -327,7 +327,7 @@ class PathValueCommitter {
 
 
     public ingestRemoteValuesAndValidStates = batchFunction(
-        { delay: 16, throttleWindow: 1000, name: "ingestRemoteValuesAndValidStates", noMeasure: true },
+        { delay: 1, throttleWindow: 1000, name: "ingestRemoteValuesAndValidStates", noMeasure: true },
         async (batched: RemoteValueAndValidState[]) => {
             const { remoteWatcher } = await import("../1-path-client/RemoteWatcher");