sliftutils 1.7.29 → 1.7.33

package/storage/remoteStorage/grantAccessCli.ts

@@ -3,9 +3,7 @@ import { RemoteStorageController } from "./storageController";
 import { authenticateStorage, parseStorageUrl } from "./ArchivesRemote";
 import { getArg } from "./cliArgs";
 
-// The grantAccess CLI. Invoked via the sibling grantAccess.js bootstrap (which loads typenode and
-// then requires this file). Grants a specific access request by its requestId; must be run on the
-// storage machine itself (its certs.ts identity is what the server trusts as admin).
+// The grantAccess CLI. Invoked via the sibling grantAccess.js bootstrap (which loads typenode and then requires this file). Grants a specific access request by its requestId; must be run on the storage machine itself (its certs.ts identity is what the server trusts as admin).
 
 async function main() {
     let url = getArg("url");

package/storage/remoteStorage/intermediateSources.d.ts

@@ -0,0 +1,21 @@
+import { RemoteConfig, HostedConfig, BackblazeConfig } from "../IArchives";
+export declare const INTERMEDIATE_EXPIRE_GRACE: number;
+/** Adding or removing intermediates is a real config update, so it takes a real version increment - but a proportional one, so it stays far below whatever the author's next version would be (whether they count 1, 2, 3 or use timestamps), and a million of them still fit under it. */
+export declare function nextIntermediateVersion(version: number): number;
+type ObjectSource = HostedConfig | BackblazeConfig;
+export declare function getIntermediateSources(config: RemoteConfig): ObjectSource[];
+export declare function hasIntermediateSources(config: RemoteConfig): boolean;
+/** Removes every intermediate entry and rejoins the windows it split, giving back the underlying configuration. Two configs that resolve equal differ only by intermediates. */
+export declare function resolveIntermediateSources(config: RemoteConfig): RemoteConfig;
+/** Splits every source at splitUrl covering [start, end) so that middle window points at intermediateUrl instead, flagged as intermediate. Idempotent: a config that already contains the exact intermediate comes back unchanged. */
+export declare function injectIntermediateSource(config: RemoteConfig, inject: {
+    splitUrl: string;
+    intermediateUrl: string;
+    start: number;
+    end: number;
+}): RemoteConfig;
+/** Intermediates whose window ended more than INTERMEDIATE_EXPIRE_GRACE ago are removed, and the windows they split are rejoined. */
+export declare function expireIntermediateSources(config: RemoteConfig, now: number): RemoteConfig;
+/** The url of the entry an intermediate was split out of - the neighbour it touches. */
+export declare function findSplitUrl(config: RemoteConfig, intermediate: ObjectSource): string | undefined;
+export {};

package/storage/remoteStorage/intermediateSources.ts

@@ -0,0 +1,117 @@
+import { RemoteConfig, RemoteConfigBase, HostedConfig, BackblazeConfig } from "../IArchives";
+
+export const INTERMEDIATE_EXPIRE_GRACE = 15 * 60 * 1000;
+const INTERMEDIATE_VERSION_FRACTION = 1_000_000;
+
+/** Adding or removing intermediates is a real config update, so it takes a real version increment - but a proportional one, so it stays far below whatever the author's next version would be (whether they count 1, 2, 3 or use timestamps), and a million of them still fit under it. */
+export function nextIntermediateVersion(version: number): number {
+    let step = Math.abs(version) / INTERMEDIATE_VERSION_FRACTION;
+    if (!(step > 0)) {
+        step = 1 / INTERMEDIATE_VERSION_FRACTION;
+    }
+    return version + step;
+}
+
+type ObjectSource = HostedConfig | BackblazeConfig;
+
+function isObjectSource(source: RemoteConfigBase): source is ObjectSource {
+    return typeof source !== "string";
+}
+
+function cloneSource(source: RemoteConfigBase): RemoteConfigBase {
+    if (!isObjectSource(source)) return source;
+    return { ...source, validWindow: [source.validWindow[0], source.validWindow[1]] };
+}
+
+function joinKey(source: ObjectSource): string {
+    return JSON.stringify({ ...source, validWindow: undefined });
+}
+
+export function getIntermediateSources(config: RemoteConfig): ObjectSource[] {
+    return config.sources.filter(x => isObjectSource(x) && x.intermediate) as ObjectSource[];
+}
+
+export function hasIntermediateSources(config: RemoteConfig): boolean {
+    return config.sources.some(x => isObjectSource(x) && x.intermediate);
+}
+
+/** Removes every intermediate entry and rejoins the windows it split, giving back the underlying configuration. Two configs that resolve equal differ only by intermediates. */
+export function resolveIntermediateSources(config: RemoteConfig): RemoteConfig {
+    if (!hasIntermediateSources(config)) return config;
+    let removed = getIntermediateSources(config);
+    let sources = config.sources.filter(x => !isObjectSource(x) || !x.intermediate).map(cloneSource);
+    for (let gap of removed) {
+        let [gapStart, gapEnd] = gap.validWindow;
+        let before = sources.find(x => isObjectSource(x) && x.validWindow[1] === gapStart) as ObjectSource | undefined;
+        let after = sources.find(x => isObjectSource(x) && x.validWindow[0] === gapEnd) as ObjectSource | undefined;
+        if (before && after && joinKey(before) === joinKey(after)) {
+            before.validWindow = [before.validWindow[0], after.validWindow[1]];
+            sources.splice(sources.indexOf(after), 1);
+            continue;
+        }
+        if (before) {
+            before.validWindow = [before.validWindow[0], gapEnd];
+            continue;
+        }
+        if (after) {
+            after.validWindow = [gapStart, after.validWindow[1]];
+        }
+    }
+    return { version: config.version, sources };
+}
+
+/** Splits every source at splitUrl covering [start, end) so that middle window points at intermediateUrl instead, flagged as intermediate. Idempotent: a config that already contains the exact intermediate comes back unchanged. */
+export function injectIntermediateSource(config: RemoteConfig, inject: { splitUrl: string; intermediateUrl: string; start: number; end: number }): RemoteConfig {
+    let { splitUrl, intermediateUrl, start, end } = inject;
+    if (start >= end) return config;
+    if (config.sources.some(x => isObjectSource(x) && x.intermediate && x.url === intermediateUrl && x.validWindow[0] === start && x.validWindow[1] === end)) {
+        return config;
+    }
+    let sources: RemoteConfigBase[] = [];
+    for (let source of config.sources) {
+        if (!isObjectSource(source) || source.url !== splitUrl || source.intermediate) {
+            sources.push(cloneSource(source));
+            continue;
+        }
+        let [windowStart, windowEnd] = source.validWindow;
+        if (windowEnd <= start || windowStart >= end) {
+            sources.push(cloneSource(source));
+            continue;
+        }
+        let middleStart = Math.max(windowStart, start);
+        let middleEnd = Math.min(windowEnd, end);
+        if (middleStart > windowStart) {
+            sources.push({ ...source, validWindow: [windowStart, middleStart] });
+        }
+        sources.push({ ...source, url: intermediateUrl, validWindow: [middleStart, middleEnd], intermediate: true });
+        if (windowEnd > middleEnd) {
+            sources.push({ ...source, validWindow: [middleEnd, windowEnd] });
+        }
+    }
+    return { version: config.version, sources };
+}
+
+/** Intermediates whose window ended more than INTERMEDIATE_EXPIRE_GRACE ago are removed, and the windows they split are rejoined. */
+export function expireIntermediateSources(config: RemoteConfig, now: number): RemoteConfig {
+    let expired = getIntermediateSources(config).filter(x => x.validWindow[1] + INTERMEDIATE_EXPIRE_GRACE < now);
+    if (!expired.length) return config;
+    let keptIntermediates = getIntermediateSources(config).filter(x => !expired.includes(x));
+    let resolved = resolveIntermediateSources(config);
+    let result = resolved;
+    for (let keep of keptIntermediates) {
+        result = injectIntermediateSource(result, {
+            splitUrl: findSplitUrl(config, keep) || keep.url,
+            intermediateUrl: keep.url,
+            start: keep.validWindow[0],
+            end: keep.validWindow[1],
+        });
+    }
+    return result;
+}
+
+/** The url of the entry an intermediate was split out of - the neighbour it touches. */
+export function findSplitUrl(config: RemoteConfig, intermediate: ObjectSource): string | undefined {
+    let [start, end] = intermediate.validWindow;
+    let neighbour = config.sources.find(x => isObjectSource(x) && !x.intermediate && (x.validWindow[1] === start || x.validWindow[0] === end)) as ObjectSource | undefined;
+    return neighbour?.url;
+}

package/storage/remoteStorage/remoteConfig.ts

@@ -4,10 +4,7 @@ import { sort, sha256HashBuffer } from "socket-function/src/misc";
 import { getBufferInt } from "socket-function/src/bits";
 import { RemoteConfig, RemoteConfigBase, HostedConfig, BackblazeConfig, FULL_VALID_WINDOW, FULL_ROUTE, VARIABLE_SHARD } from "../IArchives";
 
-// Parsing / normalization of RemoteConfig (see IArchives.ts). Every bucket stores its own
-// configuration (a RemoteConfig) inside itself, at ROUTING_FILE. Writing that file creates the
-// bucket / reconfigures it (see storageServerState.ts); clients reconcile it by version (see
-// createArchives.ts).
+// Parsing / normalization of RemoteConfig (see IArchives.ts). Every bucket stores its own configuration (a RemoteConfig) inside itself, at ROUTING_FILE. Writing that file creates the bucket / reconfigures it (see storageServerState.ts); clients reconcile it by version (see createArchives.ts).
 
 export const ROUTING_FILE = "storage/storagerouting.json";
 const ROUTING_SUFFIX = "/" + ROUTING_FILE;
@@ -125,8 +122,7 @@ export function normalizeSource(source: RemoteConfigBase): HostedConfig | Backbl
     }
     let hostname = new URL(source).hostname;
     if (hostname.endsWith(".backblazeb2.com")) {
-        // Validates the URL (throws on malformed) before it's stored; the bucket name is read back
-        // out of the URL at use sites, never stored on the config.
+        // Validates the URL (throws on malformed) before it's stored; the bucket name is read back out of the URL at use sites, never stored on the config.
         parseBackblazeUrl(source);
         return { type: "backblaze", url: source, validWindow: FULL_VALID_WINDOW };
     }
@@ -134,6 +130,18 @@ export function normalizeSource(source: RemoteConfigBase): HostedConfig | Backbl
     return { type: "remote", url: source, validWindow: FULL_VALID_WINDOW };
 }
 
+/** How far up from 0 the sources' routes reach without a gap (1 means the whole key space). */
+function getRouteCoverage(sources: (HostedConfig | BackblazeConfig)[]): number {
+    let routes = sources.map(x => x.route || FULL_ROUTE);
+    sort(routes, x => x[0]);
+    let covered = 0;
+    for (let route of routes) {
+        if (route[0] > covered) break;
+        covered = Math.max(covered, route[1]);
+    }
+    return covered;
+}
+
 export function normalizeRemoteConfig(config: RemoteConfig | RemoteConfigBase): RemoteConfig {
     let result: RemoteConfig;
     if (typeof config !== "string" && "sources" in config) {
@@ -141,11 +149,7 @@ export function normalizeRemoteConfig(config: RemoteConfig | RemoteConfigBase):
     } else {
         result = { sources: [normalizeSource(config)] };
     }
-    // Mixed immutability makes no sense AMONG sources valid at the same time: a mutable source
-    // would accept overwrites that its immutable peers refuse to synchronize, forking their
-    // contents. Sources are grouped by transitively overlapping valid windows (absorb everything
-    // overlapping the group, extend the group's end, repeat) - a soft check that is correct as
-    // long as windows have clean breaks (a group ends exactly where the next begins).
+    // Mixed immutability makes no sense AMONG sources valid at the same time: a mutable source would accept overwrites that its immutable peers refuse to synchronize, forking their contents. Sources are grouped by transitively overlapping valid windows (absorb everything overlapping the group, extend the group's end, repeat) - a soft check that is correct as long as windows have clean breaks (a group ends exactly where the next begins).
     let sources = result.sources.map(normalizeSource);
     let sorted = [...sources];
     sort(sorted, x => x.validWindow[0]);
@@ -156,18 +160,27 @@ export function normalizeRemoteConfig(config: RemoteConfig | RemoteConfigBase):
         if (immutableCount && immutableCount !== group.length) {
             throw new Error(`Sources with overlapping valid windows must agree on immutability: ${immutableCount} of ${group.length} are immutable. Sources: ${JSON.stringify(group.map(x => ({ url: x.url, validWindow: x.validWindow, immutable: !!x.immutable })))}`);
         }
-        // The sources valid at any instant must cover the whole key space, or keys routing into a
-        // gap could never be read
-        let routes = group.map(x => x.route || FULL_ROUTE);
-        sort(routes, x => x[0]);
-        let covered = 0;
-        for (let route of routes) {
-            if (route[0] > covered) break;
-            covered = Math.max(covered, route[1]);
-        }
+        // The sources valid at any instant must cover the whole key space, or keys routing into a gap could never be read
+        let covered = getRouteCoverage(group);
         if (covered < 1) {
             throw new Error(`Sources with overlapping valid windows must cover the full route space [0, 1); coverage stops at ${covered}. Sources: ${JSON.stringify(group.map(x => ({ url: x.url, validWindow: x.validWindow, route: x.route || FULL_ROUTE })))}`);
         }
+        // Every bucket must ALSO cover the full route space across its own entries, because all of a bucket's entries share one disk. A bucket that only ever synchronizes part of the key space never learns about deletions in the rest of it - and tombstones expire, so files it still holds from a route it no longer serves eventually look like live files again, and get resurrected into the chain by its next scan. An entry with no route (implicitly the full space) satisfies this on its own, which is why the usual configuration lists each bucket once per shard AND once unsharded.
+        let byUrl = new Map<string, typeof group>();
+        for (let source of group) {
+            let entries = byUrl.get(source.url);
+            if (!entries) {
+                entries = [];
+                byUrl.set(source.url, entries);
+            }
+            entries.push(source);
+        }
+        for (let [url, entries] of byUrl) {
+            let urlCovered = getRouteCoverage(entries);
+            if (urlCovered < 1) {
+                throw new Error(`Every bucket must cover the full route space [0, 1) across its own entries with overlapping valid windows, but ${url} only covers up to ${urlCovered} (its routes: ${JSON.stringify(entries.map(x => x.route || FULL_ROUTE))}). Add an entry for it with no route (or entries whose routes span the rest), alongside its sharded entries. This is enforced because a bucket's entries all share one disk: if it only ever synchronizes part of the key space, it never sees deletions in the rest, and once those tombstones expire the files it still holds are resurrected into the chain by its next scan.`);
+            }
+        }
     }
     for (let source of sorted) {
         if (group.length && source.validWindow[0] >= groupEnd) {

package/storage/remoteStorage/sourceWrapper.d.ts

@@ -1,4 +1,4 @@
-import { IArchives, HostedConfig, BackblazeConfig } from "../IArchives";
+import { IArchives, HostedConfig, BackblazeConfig, RemoteConfig } from "../IArchives";
 import { ArchivesUrl } from "./ArchivesUrl";
 export declare const RETRY_START_DELAY: number;
 export declare const RETRY_MAX_DELAY: number;
@@ -14,41 +14,30 @@ export declare class SourceWrapper {
     private reconnectRunning;
     private accessCache?;
     private constructor();
-    /** Config updates routinely just move a source's valid window (the last window extends
-     *  forever, then gets reduced when a new entry is appended). The wrapper survives that: only
-     *  the window changes, keeping the connection, pings, and latency history. */
+    /** Config updates routinely just move a source's valid window (the last window extends forever, then gets reduced when a new entry is appended). The wrapper survives that: only the window changes, keeping the connection, pings, and latency history. */
     updateValidWindow(validWindow: [number, number]): void;
     static create(config: HostedConfig | BackblazeConfig, options?: {
         background?: boolean;
     }): Promise<SourceWrapper>;
     getDebugName(): string;
     isConnected(): boolean;
-    /** Call after a request failed while isConnected() was false: starts (if not already running)
-     *  the background reconnect loop. Never blocks - the failed request still throws. */
+    /** Call after a request failed while isConnected() was false: starts (if not already running) the background reconnect loop. Never blocks - the failed request still throws. */
     noteFailure(): void;
     private reconnectLoop;
     private checkAccess;
     read<T>(run: (archives: IArchives) => Promise<T>): Promise<T>;
+    readRoutingConfig(): Promise<RemoteConfig | undefined>;
     hasWriteAccess(): Promise<boolean>;
     private pings;
     private pingTimer;
     private loggedConnected;
-    private lastTakeoverStamp;
-    /** Fired when the source's advertised takeover stamp changes (a deploy takeover started or
-     *  ended) - the chain refreshes its config, so connected clients learn within one ping. */
-    onServedConfigChanged: (() => void) | undefined;
-    /** Starts measuring this source's latency (for variable-shard target preference). Only hosted
-     *  remotes are pinged; our own local server counts as 0, everything else as Infinity. */
+    /** Starts measuring this source's latency (for variable-shard target preference). Only hosted remotes are pinged; our own local server counts as 0, everything else as Infinity. */
     startPinging(): void;
-    /** Seeds the latency estimate before the first ping lands (e.g. from the initial routing
-     *  fetch), so variable-shard picking has something immediately. Real pings take over from the
-     *  first measurement on. */
+    /** Seeds the latency estimate before the first ping lands (e.g. from the initial routing fetch), so variable-shard picking has something immediately. Real pings take over from the first measurement on. */
     seedLatency(ms: number): void;
-    /** Median of the recent pings. Sources that can't be pinged sort last (Infinity), except our
-     *  own in-process server, which is the best possible target (0). */
+    /** Median of the recent pings. Sources that can't be pinged sort last (Infinity), except our own in-process server, which is the best possible target (0). */
     getLatency(): number;
-    /** Writes always go through the API, so a permission error throws to the caller on every write
-     *  (and access granted in the meantime is picked up automatically). */
+    /** Writes always go through the API, so a permission error throws to the caller on every write (and access granted in the meantime is picked up automatically). */
     write<T>(run: (archives: IArchives) => Promise<T>): Promise<T>;
     dispose(): void;
 }

package/storage/remoteStorage/sourceWrapper.ts

@@ -3,8 +3,8 @@ module.allowclient = true;
 import { isNode, sort } from "socket-function/src/misc";
 import { delay } from "socket-function/src/batching";
 import { getSecret } from "../../misc/getSecret";
-import { IArchives, HostedConfig, BackblazeConfig } from "../IArchives";
-import { ROUTING_FILE, getBucketBaseUrl, parseHostedUrl, parseBackblazeUrl } from "./remoteConfig";
+import { IArchives, HostedConfig, BackblazeConfig, RemoteConfig } from "../IArchives";
+import { ROUTING_FILE, getBucketBaseUrl, parseHostedUrl, parseBackblazeUrl, parseRoutingData } from "./remoteConfig";
 import { ArchivesRemote } from "./ArchivesRemote";
 import { ArchivesUrl } from "./ArchivesUrl";
 import { ArchivesBackblaze } from "../backblaze";
@@ -28,12 +28,7 @@ async function hasBackblazeCreds(): Promise<boolean> {
     }
 }
 
-// One source of a RemoteConfig, as a usable IArchives. Reads fall back to the public-URL form when
-// we don't have API access; writes always attempt the API (so access granted later is picked up on
-// the next write). When a call fails while the WebSocket is down, noteFailure starts a background
-// reconnect loop with a ramping delay - it never blocks callers, it just keeps trying so the
-// connection eventually comes back. Sources without a WebSocket (backblaze, URL-form, our own
-// local server) report always-connected: they're last-resort sources where throwing is fine.
+// One source of a RemoteConfig, as a usable IArchives. Reads fall back to the public-URL form when we don't have API access; writes always attempt the API (so access granted later is picked up on the next write). When a call fails while the WebSocket is down, noteFailure starts a background reconnect loop with a ramping delay - it never blocks callers, it just keeps trying so the connection eventually comes back. Sources without a WebSocket (backblaze, URL-form, our own local server) report always-connected: they're last-resort sources where throwing is fine.
 export class SourceWrapper {
     public api?: IArchives;
     public url?: ArchivesUrl;
@@ -49,9 +44,7 @@ export class SourceWrapper {
         private background: boolean,
     ) { }
 
-    /** Config updates routinely just move a source's valid window (the last window extends
-     *  forever, then gets reduced when a new entry is appended). The wrapper survives that: only
-     *  the window changes, keeping the connection, pings, and latency history. */
+    /** Config updates routinely just move a source's valid window (the last window extends forever, then gets reduced when a new entry is appended). The wrapper survives that: only the window changes, keeping the connection, pings, and latency history. */
     public updateValidWindow(validWindow: [number, number]): void {
         let old = this.config.validWindow;
         if (old[0] === validWindow[0] && old[1] === validWindow[1]) return;
@@ -81,7 +74,7 @@ export class SourceWrapper {
             wrapper.api = getLocalArchives(parsed.account, parsed.bucketName);
             return wrapper;
         }
-        wrapper.remote = new ArchivesRemote({ url: config.url, accountName: config.accountName, waitForAccess: false });
+        wrapper.remote = new ArchivesRemote({ url: config.url, waitForAccess: false });
         wrapper.api = wrapper.remote;
         if (config.public !== false) {
             wrapper.url = new ArchivesUrl(getBucketBaseUrl(config.url));
@@ -90,8 +83,7 @@ export class SourceWrapper {
     }
 
     public getDebugName(): string {
-        // The same URL can appear as multiple sources (different routes / valid windows), so the
-        // distinguishing slice is part of the name
+        // The same URL can appear as multiple sources (different routes / valid windows), so the distinguishing slice is part of the name
         let parts: string[] = [];
         let route = this.config.route;
         if (route) {
@@ -111,8 +103,7 @@ export class SourceWrapper {
         return this.remote.isConnected();
     }
 
-    /** Call after a request failed while isConnected() was false: starts (if not already running)
-     *  the background reconnect loop. Never blocks - the failed request still throws. */
+    /** Call after a request failed while isConnected() was false: starts (if not already running) the background reconnect loop. Never blocks - the failed request still throws. */
     public noteFailure(): void {
         if (!this.background || this.disposed || this.reconnectRunning) return;
         if (this.isConnected()) return;
@@ -145,9 +136,7 @@ export class SourceWrapper {
         console.log(`Reconnected to storage ${this.getDebugName()}`);
     }
 
-    // For hosted sources: cached access check, so reads know whether to use the API or the public
-    // URL form. Access, once seen, is assumed to stick; no-access is re-checked periodically (the
-    // check also registers our access request server-side, which logs the grant link).
+    // For hosted sources: cached access check, so reads know whether to use the API or the public URL form. Access, once seen, is assumed to stick; no-access is re-checked periodically (the check also registers our access request server-side, which logs the grant link).
     private async checkAccess(): Promise<boolean> {
         let remote = this.remote;
         if (!remote) return !!this.api;
@@ -171,13 +160,17 @@ export class SourceWrapper {
             return await run(this.url);
         }
         if (this.api) {
-            // No public URL form - let the API call throw its own error (which includes the access
-            // instructions for hosted sources)
+            // No public URL form - let the API call throw its own error (which includes the access instructions for hosted sources)
             return await run(this.api);
         }
         throw new Error(`Source ${this.config.url} has no API access and no public URL form (public: false)`);
     }
 
+    public async readRoutingConfig(): Promise<RemoteConfig | undefined> {
+        let data = await this.read(archives => archives.get(ROUTING_FILE));
+        return data && parseRoutingData(data) || undefined;
+    }
+
     public async hasWriteAccess(): Promise<boolean> {
         if (this.writeBlocked || !this.api) return false;
         return await this.api.hasWriteAccess();
@@ -186,21 +179,15 @@ export class SourceWrapper {
     private pings: number[] = [];
     private pingTimer: ReturnType<typeof setInterval> | undefined;
     private loggedConnected = false;
-    private lastTakeoverStamp: string | undefined;
-    /** Fired when the source's advertised takeover stamp changes (a deploy takeover started or
-     *  ended) - the chain refreshes its config, so connected clients learn within one ping. */
-    public onServedConfigChanged: (() => void) | undefined;
 
-    /** Starts measuring this source's latency (for variable-shard target preference). Only hosted
-     *  remotes are pinged; our own local server counts as 0, everything else as Infinity. */
+    /** Starts measuring this source's latency (for variable-shard target preference). Only hosted remotes are pinged; our own local server counts as 0, everything else as Infinity. */
     public startPinging(): void {
         const remote = this.remote;
         if (!remote || this.pingTimer || this.disposed) return;
         let measure = async () => {
             let start = Date.now();
-            let result: { takeover?: string } | undefined;
             try {
-                result = await remote.ping();
+                await remote.ping();
             } catch {
                 // A failed ping is also our earliest down-detection
                 this.noteFailure();
@@ -214,11 +201,6 @@ export class SourceWrapper {
             if (this.pings.length > PING_HISTORY) {
                 this.pings.shift();
             }
-            let stamp = result?.takeover;
-            if (stamp !== this.lastTakeoverStamp) {
-                this.lastTakeoverStamp = stamp;
-                this.onServedConfigChanged?.();
-            }
         };
         void measure();
         this.pingTimer = setInterval(() => {
@@ -227,16 +209,13 @@ export class SourceWrapper {
         (this.pingTimer as { unref?: () => void }).unref?.();
     }
 
-    /** Seeds the latency estimate before the first ping lands (e.g. from the initial routing
-     *  fetch), so variable-shard picking has something immediately. Real pings take over from the
-     *  first measurement on. */
+    /** Seeds the latency estimate before the first ping lands (e.g. from the initial routing fetch), so variable-shard picking has something immediately. Real pings take over from the first measurement on. */
     public seedLatency(ms: number): void {
         if (this.pings.length) return;
         this.pings.push(ms);
     }
 
-    /** Median of the recent pings. Sources that can't be pinged sort last (Infinity), except our
-     *  own in-process server, which is the best possible target (0). */
+    /** Median of the recent pings. Sources that can't be pinged sort last (Infinity), except our own in-process server, which is the best possible target (0). */
     public getLatency(): number {
         if (!this.remote) {
             if (this.config.type === "remote" && this.api) return 0;
@@ -248,8 +227,7 @@ export class SourceWrapper {
         return sorted[Math.floor(sorted.length / 2)];
     }
 
-    /** Writes always go through the API, so a permission error throws to the caller on every write
-     *  (and access granted in the meantime is picked up automatically). */
+    /** Writes always go through the API, so a permission error throws to the caller on every write (and access granted in the meantime is picked up automatically). */
     public async write<T>(run: (archives: IArchives) => Promise<T>): Promise<T> {
         if (this.writeBlocked) {
             throw new Error(this.writeBlocked);

package/storage/remoteStorage/storageClientController.ts

@@ -1,8 +1,6 @@
 import { SocketFunction } from "socket-function/SocketFunction";
 
-// The client half of routing-change broadcasts: the storage server tracks its connected clients
-// (see trackCaller in storageController) and calls routingConfigChanged on every one of them the
-// moment a routing config changes - clients react immediately instead of waiting for a poll.
+// The client half of routing-change broadcasts: the storage server tracks its connected clients (see trackCaller in storageController) and calls routingConfigChanged on every one of them the moment a routing config changes - clients react immediately instead of waiting for a poll.
 
 const listeners = new Set<() => void>();
 

package/storage/remoteStorage/storageController.d.ts

@@ -36,10 +36,9 @@ export type AccessState = {
     grantAccessCommand?: string;
     trustedMachines?: TrustRecord[];
 };
+export declare function broadcastRoutingChanged(): void;
 export declare const RemoteStorageController: import("socket-function/SocketFunctionTypes").SocketRegistered<{
-    ping: () => Promise<{
-        takeover?: string;
-    }>;
+    ping: () => Promise<{}>;
     authenticate: (token: AuthToken) => Promise<{
         machineId: string;
         ip: string;
@@ -80,6 +79,9 @@ export declare const RemoteStorageController: import("socket-function/SocketFunc
     getChangesAfter: (account: string, bucketName: string, time: number) => Promise<ArchiveFileInfo[]>;
     getArchivesConfig: (account: string, bucketName: string) => Promise<ArchivesConfig>;
     listBuckets: (account: string) => Promise<ServerBucketInfo[]>;
+    clearWriteStats: (account: string) => Promise<{
+        clearedBuckets: number;
+    }>;
     getIndexInfo: (account: string, bucketName: string) => Promise<{
         fileCount: number;
         byteCount: number;