sliftutils 1.7.96 → 1.7.97

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "sliftutils",
-    "version": "1.7.96",
+    "version": "1.7.97",
     "main": "index.js",
     "license": "MIT",
     "files": [

package/storage/remoteStorage/createArchives.ts

@@ -404,9 +404,7 @@ export class ArchivesChain implements IArchives {
             })();
             if ("values" in outcome) return outcome.values;
             let error = outcome.error;
-            if (Date.now() >= deadline) {
-                throw error;
-            }
+            // Substitution comes BEFORE the deadline check: a single connect timeout can eat the entire deadline, and giving up then - without ever trying the substitute that fallbacks exist for - throws exactly when falling back matters most. Substitution cannot loop past the deadline forever: every pass adds its failures to `failed`, so the substitutes run out with the sources.
             if (config?.fallbacks && failed.size) {
                 let substitutable = false;
                 try {
@@ -420,6 +418,9 @@ export class ArchivesChain implements IArchives {
                 // No substitute covers the failed routes - retry the failed sources themselves after the delay
                 failed.clear();
             }
+            if (Date.now() >= deadline) {
+                throw error;
+            }
             console.error(`${error.message}. Retrying in ${COVERING_RETRY_DELAY / 1000}s (giving up at ${new Date(deadline).toISOString()}).`);
             void this.state.recheckAvailability();
             await delay(COVERING_RETRY_DELAY);

package/storage/remoteStorage/dist/chainStartup.ts.cache

@@ -0,0 +1,466 @@
+"use strict"; var console = (function shimConsole() {             let baseConsole = globalThis.console;             if (typeof window !== "undefined")                 return baseConsole;             let name = __filename.replaceAll("\\", "/").split("/").pop();             let dirName = __dirname.replaceAll("\\", "/").split("/").pop();             let context = {                 __FILE__: __filename,                 __DIR__: __dirname,                 __NAME__: name,                 __DIRNAME__: dirName             };             let newConsole = {                 ...baseConsole             };             for (let shim of ["log", "info", "warn", "error"]) {                 newConsole[shim] = (...args) => {                     args.push(context);                     baseConsole[shim](...args);                 };             }             newConsole.__context = context;             return newConsole;         })(); "use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.RoutingRewriteLoop = exports.writeRoutingToAllStores = exports.chooseStartupConfig = exports.disposeProbes = exports.probeSources = exports.ChainStateManager = exports.CONFIG_WRITE_REFRESH_INTERVAL = exports.CONFIG_WRITE_RETRY_INTERVAL = void 0;
+const misc_1 = require("socket-function/src/misc");
+const remoteConfig_1 = require("./remoteConfig");
+const sourceWrapper_1 = require("./sourceWrapper");
+const intermediateSources_1 = require("./intermediateSources");
+const storageClientController_1 = require("./storageClientController");
+// The LIFECYCLE of an ArchivesChain's state, and nothing else: initializing it (probing every configured source, deciding which routing config to run, writing ours out when it is the newest), the retry when initialization fails, the poll that adopts newer configs, the availability recheck, and the loop that keeps re-writing our config. None of this is request dispatch - the chain (createArchives.ts) asks the ChainStateManager for the current state and dispatches over it.
+const CONFIG_POLL_INTERVAL = 5 * 60 * 1000;
+const AVAILABILITY_RECHECK_THROTTLE = 5 * 1000;
+// The routing config write is retried on this cadence while it is failing. A store that never received the config rejects every write aimed at it, so this not landing is a big deal - each failed attempt is logged.
+exports.CONFIG_WRITE_RETRY_INTERVAL = 5 * 60 * 1000;
+// ...and even after success it is re-written on this cadence, in case a store lost it or a server appeared late
+exports.CONFIG_WRITE_REFRESH_INTERVAL = 60 * 60 * 1000;
+/** The chain's state and everything about HAVING one: init (with its retry), the config poll, availability rechecks, and the routing rewrite loop. The chain constructs one, asks it getState() on every call, and disposes it. */
+class ChainStateManager {
+    constructor(config) {
+        this.config = config;
+        this.initRetryDelay = sourceWrapper_1.RETRY_START_DELAY;
+        this.disposed = false;
+        this.lastAvailabilityRecheck = 0;
+        this.configured = config.configured;
+        this.activeConfig = config.configured;
+        this.routingRewriter = new RoutingRewriteLoop({
+            configured: config.configured,
+            debugName: config.debugName,
+            latest: () => this.latestState,
+        });
+        this.unsubscribeRoutingPush = (0, storageClientController_1.onServerRoutingChanged)(() => {
+            void this.refreshActiveConfig().catch((e) => { var _a; return console.error(`Config refresh failed for ${this.config.debugName()}: ${(_a = e.stack) !== null && _a !== void 0 ? _a : e}`); });
+        });
+    }
+    /** The newest adopted state, synchronously - undefined until the first init finishes. */
+    latest() {
+        return this.latestState;
+    }
+    getState() {
+        if (this.disposed) {
+            return Promise.reject(new Error(`ArchivesChain ${this.config.debugName()} has been disposed`));
+        }
+        if (!this.statePromise) {
+            let promise = this.init();
+            this.statePromise = promise;
+            promise.then(() => {
+                this.initRetryDelay = sourceWrapper_1.RETRY_START_DELAY;
+            }, (e) => {
+                var _a, _b, _c;
+                if (this.disposed || this.initRetryTimer)
+                    return;
+                console.error(`Storage init failed for ${this.config.debugName()}, retrying in ${Math.round(this.initRetryDelay / 1000)}s. ${(_a = e.stack) !== null && _a !== void 0 ? _a : e}`);
+                this.initRetryTimer = setTimeout(() => {
+                    this.initRetryTimer = undefined;
+                    if (this.disposed)
+                        return;
+                    if (this.statePromise === promise) {
+                        this.statePromise = undefined;
+                    }
+                    this.getState().catch(() => { });
+                }, this.initRetryDelay);
+                (_c = (_b = this.initRetryTimer).unref) === null || _c === void 0 ? void 0 : _c.call(_b);
+                this.initRetryDelay = Math.min(sourceWrapper_1.RETRY_MAX_DELAY, this.initRetryDelay * sourceWrapper_1.RETRY_GROWTH);
+            });
+        }
+        return this.statePromise;
+    }
+    async init() {
+        let configs = this.configured.sources.map(remoteConfig_1.normalizeSource);
+        let readOnly = this.isReadOnly(this.configured);
+        let probes = await probeSources(configs, readOnly);
+        try {
+            let { active, needsWrite, existing } = chooseStartupConfig({ configured: this.configured, probes, debugName: this.config.debugName() });
+            let sources = await this.buildSources(active);
+            let configWriteFailed = false;
+            if (needsWrite) {
+                console.log(`Storage routing config for ${this.config.debugName()} is out of date (stored version ${existing && (0, remoteConfig_1.getConfigVersion)(existing) || "none"}, ours ${(0, remoteConfig_1.getConfigVersion)(this.configured)})`);
+                let { failures, total } = await writeRoutingToAllStores({ configured: this.configured, sources, debugName: this.config.debugName() });
+                configWriteFailed = failures.length > 0;
+                if (failures.length && failures.length === total) {
+                    // Nobody has our config, so running on it would just disagree with every server. The stored one (when there is one) is what the servers actually run.
+                    console.error(`The storage routing config for ${this.config.debugName()} (version ${(0, remoteConfig_1.getConfigVersion)(this.configured)}) could not be written to ANY of the ${total} stores. ${existing && `Running on the stored config (version ${(0, remoteConfig_1.getConfigVersion)(existing)}) until a write succeeds.` || `No stored config exists either, so servers will reject writes until this succeeds.`} Retrying in ${exports.CONFIG_WRITE_RETRY_INTERVAL / 1000}s. Failures: ${failures.join(" | ")}`);
+                    if (existing) {
+                        active = existing;
+                        for (let source of sources) {
+                            source.dispose();
+                        }
+                        sources = await this.buildSources(active);
+                    }
+                }
+                else if (failures.length) {
+                    console.error(`The storage routing config for ${this.config.debugName()} (version ${(0, remoteConfig_1.getConfigVersion)(this.configured)}) was written to ${total - failures.length} of ${total} stores. Retrying the rest in ${exports.CONFIG_WRITE_RETRY_INTERVAL / 1000}s (they also pull it from the stores that have it). Failures: ${failures.join(" | ")}`);
+                }
+            }
+            for (let source of sources) {
+                let probe = probes.find(x => x.responded && x.sourceConfig.url === source.config.url);
+                if (probe) {
+                    source.seedLatency(probe.latency);
+                }
+            }
+            this.activeConfig = active;
+            this.startConfigPoll();
+            let state = { config: active, sources };
+            this.latestState = state;
+            this.routingRewriter.start(configWriteFailed);
+            return state;
+        }
+        finally {
+            disposeProbes(probes);
+        }
+    }
+    /** Clientside, a config with public sources is served entirely over plain URL downloads - no API connection, no access grant, and no writing. directConnect opts out of that. */
+    isReadOnly(config) {
+        if (this.config.directConnect || (0, misc_1.isNode)())
+            return false;
+        return config.sources.map(remoteConfig_1.normalizeSource).some(x => x.public);
+    }
+    async createChainSource(sourceConfig, readOnly) {
+        let source = await sourceWrapper_1.SourceWrapper.create(sourceConfig, { readOnly });
+        source.startPinging();
+        return source;
+    }
+    async buildSources(config) {
+        let readOnly = this.isReadOnly(config);
+        let sources = [];
+        for (let sourceConfig of config.sources.map(remoteConfig_1.normalizeSource)) {
+            sources.push(await this.createChainSource(sourceConfig, readOnly));
+        }
+        return sources;
+    }
+    startConfigPoll() {
+        var _a, _b;
+        if (this.pollTimer || this.disposed)
+            return;
+        this.pollTimer = setInterval(() => {
+            void this.refreshActiveConfig().catch((e) => {
+                var _a;
+                console.error(`Checking for a new storage routing config failed for ${this.config.debugName()}: ${(_a = e.stack) !== null && _a !== void 0 ? _a : e}`);
+            });
+        }, CONFIG_POLL_INTERVAL);
+        (_b = (_a = this.pollTimer).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
+    }
+    refreshActiveConfig() {
+        if (!this.configRefreshInFlight) {
+            this.configRefreshInFlight = this.checkForNewConfig().finally(() => {
+                this.configRefreshInFlight = undefined;
+            });
+        }
+        return this.configRefreshInFlight;
+    }
+    async fetchLatestConfig(state) {
+        var _a;
+        let errors = [];
+        for (let source of state.sources) {
+            try {
+                let latest = await source.readRoutingConfig();
+                if (latest)
+                    return (0, remoteConfig_1.normalizeRemoteConfig)(latest);
+            }
+            catch (e) {
+                errors.push(`${source.config.url}: ${(_a = e.stack) !== null && _a !== void 0 ? _a : e}`);
+            }
+        }
+        if (errors.length === state.sources.length) {
+            throw new Error(`No storage source could give us the routing config for ${this.config.debugName()}: ${errors.join(" | ")}`);
+        }
+        return undefined;
+    }
+    async checkForNewConfig() {
+        if (this.disposed || !this.statePromise)
+            return;
+        let state;
+        try {
+            state = await this.statePromise;
+        }
+        catch (_a) {
+            return;
+        }
+        let latest = await this.fetchLatestConfig(state);
+        if (!latest)
+            return;
+        await this.adoptNewConfig(state, latest);
+    }
+    async adoptNewConfig(state, latest) {
+        var _a;
+        if (JSON.stringify(latest) === JSON.stringify(state.config))
+            return;
+        let received = new Date().toISOString();
+        let onlyIntermediatesChanged = JSON.stringify((0, intermediateSources_1.resolveIntermediateSources)(latest)) === JSON.stringify((0, intermediateSources_1.resolveIntermediateSources)(state.config));
+        if (onlyIntermediatesChanged) {
+            console.log(`Storage routing switchover windows changed (version ${(0, remoteConfig_1.getConfigVersion)(state.config)} -> ${(0, remoteConfig_1.getConfigVersion)(latest)}), received ${received}, rebuilding sources. New config: ${JSON.stringify(latest)}`);
+        }
+        else {
+            console.log(`Storage routing config changed (version ${(0, remoteConfig_1.getConfigVersion)(state.config)} -> ${(0, remoteConfig_1.getConfigVersion)(latest)}), received ${received}, rebuilding sources. New config: ${JSON.stringify(latest)}`);
+        }
+        let strippedKey = (config) => JSON.stringify({ ...config, validWindow: undefined });
+        let oldByConfig = new Map();
+        for (let source of state.sources) {
+            let key = strippedKey(source.config);
+            let list = oldByConfig.get(key);
+            if (!list) {
+                list = [];
+                oldByConfig.set(key, list);
+            }
+            list.push(source);
+        }
+        let readOnly = this.isReadOnly(latest);
+        let sources = [];
+        for (let sourceConfig of latest.sources.map(remoteConfig_1.normalizeSource)) {
+            let old = (_a = oldByConfig.get(strippedKey(sourceConfig))) === null || _a === void 0 ? void 0 : _a.shift();
+            if (old) {
+                old.updateValidWindow(sourceConfig.validWindow);
+                sources.push(old);
+            }
+            else {
+                sources.push(await this.createChainSource(sourceConfig, readOnly));
+            }
+        }
+        for (let leftovers of oldByConfig.values()) {
+            for (let leftover of leftovers) {
+                leftover.dispose();
+            }
+        }
+        this.activeConfig = latest;
+        let newState = { config: latest, sources };
+        this.latestState = newState;
+        this.statePromise = Promise.resolve(newState);
+    }
+    /** Every source failed: re-contact all of them (routing re-read + connection re-attempt) and adopt whatever config comes back. Throttled, and deduplicated across concurrent callers. */
+    recheckAvailability() {
+        if (this.availabilityRecheckInFlight)
+            return this.availabilityRecheckInFlight;
+        if (Date.now() - this.lastAvailabilityRecheck < AVAILABILITY_RECHECK_THROTTLE)
+            return Promise.resolve();
+        this.lastAvailabilityRecheck = Date.now();
+        this.availabilityRecheckInFlight = this.recheckAvailabilityNow().finally(() => {
+            this.availabilityRecheckInFlight = undefined;
+        });
+        return this.availabilityRecheckInFlight;
+    }
+    async recheckAvailabilityNow() {
+        if (this.disposed || !this.statePromise)
+            return;
+        let state;
+        try {
+            state = await this.statePromise;
+        }
+        catch (_a) {
+            return;
+        }
+        console.log(`Every storage source failed for ${this.config.debugName()}; re-contacting all ${state.sources.length} sources (routing re-read + connection re-attempt)`);
+        let results = await Promise.all(state.sources.map(async (source) => {
+            try {
+                return await source.readRoutingConfig();
+            }
+            catch (_a) {
+                return undefined;
+            }
+        }));
+        let latest = results.find(x => x);
+        if (!latest)
+            return;
+        await this.adoptNewConfig(state, latest);
+    }
+    dispose() {
+        var _a;
+        this.disposed = true;
+        (_a = this.unsubscribeRoutingPush) === null || _a === void 0 ? void 0 : _a.call(this);
+        if (this.pollTimer) {
+            clearInterval(this.pollTimer);
+        }
+        if (this.initRetryTimer) {
+            clearTimeout(this.initRetryTimer);
+        }
+        this.routingRewriter.dispose();
+        let statePromise = this.statePromise;
+        if (statePromise) {
+            void statePromise.then(state => {
+                for (let source of state.sources) {
+                    source.dispose();
+                }
+            }, () => { });
+        }
+    }
+}
+exports.ChainStateManager = ChainStateManager;
+/** One throwaway SourceWrapper per configured source, each asked for its stored routing config - which also measures first-contact latency, seeded into the real sources afterwards. The probes MUST be disposed (disposeProbes) once the caller is done with them. */
+async function probeSources(configs, readOnly) {
+    return await Promise.all(configs.map(async (sourceConfig) => {
+        var _a;
+        let probe = await sourceWrapper_1.SourceWrapper.create(sourceConfig, { background: false, readOnly });
+        let start = Date.now();
+        try {
+            let existing = await probe.readRoutingConfig();
+            return { probe, sourceConfig, responded: true, latency: Date.now() - start, existing, error: "" };
+        }
+        catch (e) {
+            return { probe, sourceConfig, responded: false, latency: 0, existing: undefined, error: `${sourceConfig.url}: ${(_a = e.stack) !== null && _a !== void 0 ? _a : e}` };
+        }
+    }));
+}
+exports.probeSources = probeSources;
+function disposeProbes(probes) {
+    for (let probe of probes) {
+        probe.probe.dispose();
+    }
+}
+exports.disposeProbes = disposeProbes;
+/**
+ * Which routing config the chain should RUN: the newest of ours and every stored one. needsWrite
+ * when ours is strictly the newest, meaning the stores have to be told about it. A stored config
+ * with our exact version but DIFFERENT content wins without a write, loudly: config updates must
+ * bump the version, or they are ignored - silently taking the changed one would make "what is the
+ * bucket running" depend on which process started last.
+ *
+ * Throws when no source answered at all: with nothing stored and nobody to write to, there is no
+ * config to run.
+ */
+function chooseStartupConfig(config) {
+    let { configured, probes, debugName } = config;
+    let found = probes.find(x => x.responded);
+    if (!found) {
+        throw new Error(`Cannot initialize storage for ${debugName}: no source answered. ${probes.map(x => x.error).join(" | ")}`);
+    }
+    let existing = found.existing;
+    let active = configured;
+    let needsWrite = true;
+    if (existing && (0, remoteConfig_1.getConfigVersion)(existing) >= (0, remoteConfig_1.getConfigVersion)(configured)) {
+        if ((0, remoteConfig_1.getConfigVersion)(existing) === (0, remoteConfig_1.getConfigVersion)(configured) && JSON.stringify(existing) !== JSON.stringify(configured)) {
+            console.error(`Archives configuration updated without updating the version, for ${found.sourceConfig.url}. Updates will be ignored until you increase the version. Using: ${JSON.stringify(existing)}, ignoring: ${JSON.stringify(configured)}`);
+        }
+        active = existing;
+        needsWrite = false;
+    }
+    if (needsWrite) {
+        let best;
+        let conflictUrl;
+        for (let probe of probes) {
+            let stored = probe.existing;
+            if (!stored)
+                continue;
+            if (!best || (0, remoteConfig_1.getConfigVersion)(stored) > (0, remoteConfig_1.getConfigVersion)(best)) {
+                best = stored;
+            }
+            if ((0, remoteConfig_1.getConfigVersion)(stored) === (0, remoteConfig_1.getConfigVersion)(configured) && JSON.stringify(stored) !== JSON.stringify(configured)) {
+                conflictUrl = probe.sourceConfig.url;
+            }
+        }
+        if (best && (0, remoteConfig_1.getConfigVersion)(best) >= (0, remoteConfig_1.getConfigVersion)(configured)) {
+            if (conflictUrl && (0, remoteConfig_1.getConfigVersion)(best) === (0, remoteConfig_1.getConfigVersion)(configured)) {
+                console.error(`Archives configuration updated without updating the version, for ${conflictUrl}. Updates will be ignored until you increase the version. Using: ${JSON.stringify(best)}, ignoring: ${JSON.stringify(configured)}`);
+            }
+            active = best;
+            needsWrite = false;
+        }
+    }
+    return { active, needsWrite, existing };
+}
+exports.chooseStartupConfig = chooseStartupConfig;
+/**
+ * Writes the given routing config to every configured store, one write per url+name: the write
+ * lands in the store the entry NAMES, so two entries sharing a URL but naming different stores are
+ * two separate deliveries - deduping by URL alone leaves the second store unconfigured forever. All
+ * in parallel, every failure tolerated (no-write-access included - the attempt classifies it,
+ * nothing pre-checks it): a down node must not stop the others from getting the config - they would
+ * then reject writes as unconfigured precisely BECAUSE it never arrived - and it must never stop
+ * the chain from starting. A store that missed it pulls it off its peers, and the rewrite loop
+ * tries again (see RoutingRewriteLoop).
+ */
+async function writeRoutingToAllStores(config) {
+    let { configured, sources, debugName } = config;
+    let routingData = (0, remoteConfig_1.serializeRemoteConfig)(configured);
+    let routingWriteTime = Date.now();
+    let targets = [];
+    let seen = new Set();
+    for (let source of sources) {
+        let key = `${source.config.url}|${source.config.name}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        targets.push(source);
+    }
+    console.log(`Writing routing config version ${(0, remoteConfig_1.getConfigVersion)(configured)} for ${debugName} to all ${targets.length} stores (write time ${new Date(routingWriteTime).toISOString()}): ${targets.map(x => `${x.config.url} (store ${JSON.stringify(x.config.name)})`).join(", ")}`);
+    let failures = [];
+    await Promise.all(targets.map(async (source) => {
+        var _a;
+        try {
+            await source.write(archives => archives.set(remoteConfig_1.ROUTING_FILE, routingData, { lastModified: routingWriteTime }));
+            console.log(`Wrote storage routing config version ${(0, remoteConfig_1.getConfigVersion)(configured)} to ${source.config.url} (store ${JSON.stringify(source.config.name)})`);
+        }
+        catch (e) {
+            failures.push(`${source.config.url} (store ${JSON.stringify(source.config.name)}): ${(_a = e.stack) !== null && _a !== void 0 ? _a : e}`);
+        }
+    }));
+    return { failures, total: targets.length };
+}
+exports.writeRoutingToAllStores = writeRoutingToAllStores;
+/**
+ * The periodic re-write of the chain's in-code config: failures retried on the short interval - a
+ * store without the config rejects every write aimed at it, so this not landing is a big deal,
+ * logged on every attempt - and even success repeated hourly, in case a store lost it. The failure
+ * this exists for: a server whose trust was only granted AFTER startup, so the startup write was
+ * rejected and nothing else would ever retry it.
+ */
+class RoutingRewriteLoop {
+    constructor(config) {
+        this.config = config;
+        this.disposed = false;
+    }
+    /** (Re)arms the loop - called at the end of every init, with whether that init's write failed (which picks the short retry interval). */
+    start(failedAtStartup) {
+        this.schedule(failedAtStartup && exports.CONFIG_WRITE_RETRY_INTERVAL || exports.CONFIG_WRITE_REFRESH_INTERVAL);
+    }
+    dispose() {
+        this.disposed = true;
+        if (this.timer) {
+            clearTimeout(this.timer);
+        }
+    }
+    schedule(delay) {
+        var _a, _b;
+        if (this.disposed)
+            return;
+        if (this.timer) {
+            clearTimeout(this.timer);
+        }
+        this.timer = setTimeout(() => {
+            this.timer = undefined;
+            void this.rewrite().catch((e) => {
+                var _a;
+                console.error(`Rewriting the storage routing config for ${this.config.debugName()} failed: ${(_a = e.stack) !== null && _a !== void 0 ? _a : e}`);
+                this.schedule(exports.CONFIG_WRITE_RETRY_INTERVAL);
+            });
+        }, delay);
+        (_b = (_a = this.timer).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
+    }
+    async rewrite() {
+        if (this.disposed)
+            return;
+        let configured = this.config.configured;
+        let state = this.config.latest();
+        if (!state) {
+            this.schedule(exports.CONFIG_WRITE_RETRY_INTERVAL);
+            return;
+        }
+        // The bucket adopted a NEWER config than our in-code one, so ours is stale and every store would (rightly) refuse it
+        if ((0, remoteConfig_1.getConfigVersion)(state.config) > (0, remoteConfig_1.getConfigVersion)(configured)) {
+            this.schedule(exports.CONFIG_WRITE_REFRESH_INTERVAL);
+            return;
+        }
+        // Same version but different content: startup already decided the stored one wins until the version is bumped (see chooseStartupConfig), and re-writing ours would flip the bucket back and forth between the two
+        if ((0, remoteConfig_1.getConfigVersion)(state.config) === (0, remoteConfig_1.getConfigVersion)(configured) && JSON.stringify(state.config) !== JSON.stringify(configured)) {
+            this.schedule(exports.CONFIG_WRITE_REFRESH_INTERVAL);
+            return;
+        }
+        let { failures, total } = await writeRoutingToAllStores({ configured, sources: state.sources, debugName: this.config.debugName() });
+        if (failures.length) {
+            console.error(`The periodic routing config write for ${this.config.debugName()} (version ${(0, remoteConfig_1.getConfigVersion)(configured)}) failed on ${failures.length} of ${total} stores - retrying in ${exports.CONFIG_WRITE_RETRY_INTERVAL / 1000}s: ${failures.join(" | ")}`);
+            this.schedule(exports.CONFIG_WRITE_RETRY_INTERVAL);
+            return;
+        }
+        this.schedule(exports.CONFIG_WRITE_REFRESH_INTERVAL);
+    }
+}
+exports.RoutingRewriteLoop = RoutingRewriteLoop;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"chainStartup.js","sourceRoot":"","sources":["chainStartup.ts"],"names":[],"mappings":"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","sourcesContent":["import { isNode } from \"socket-function/src/misc\";\nimport { RemoteConfig, SourceConfig } from \"../IArchives\";\nimport { ROUTING_FILE, getConfigVersion, serializeRemoteConfig, normalizeRemoteConfig, normalizeSource } from \"./remoteConfig\";\nimport { SourceWrapper, RETRY_START_DELAY, RETRY_MAX_DELAY, RETRY_GROWTH } from \"./sourceWrapper\";\nimport { resolveIntermediateSources } from \"./intermediateSources\";\nimport { onServerRoutingChanged } from \"./storageClientController\";\n\n// The LIFECYCLE of an ArchivesChain's state, and nothing else: initializing it (probing every configured source, deciding which routing config to run, writing ours out when it is the newest), the retry when initialization fails, the poll that adopts newer configs, the availability recheck, and the loop that keeps re-writing our config. None of this is request dispatch - the chain (createArchives.ts) asks the ChainStateManager for the current state and dispatches over it.\n\nconst CONFIG_POLL_INTERVAL = 5 * 60 * 1000;\nconst AVAILABILITY_RECHECK_THROTTLE = 5 * 1000;\n// The routing config write is retried on this cadence while it is failing. A store that never received the config rejects every write aimed at it, so this not landing is a big deal - each failed attempt is logged.\nexport const CONFIG_WRITE_RETRY_INTERVAL = 5 * 60 * 1000;\n// ...and even after success it is re-written on this cadence, in case a store lost it or a server appeared late\nexport const CONFIG_WRITE_REFRESH_INTERVAL = 60 * 60 * 1000;\n\nexport type ChainState = {\n    config: RemoteConfig;\n    sources: SourceWrapper[];\n};\n\n/** The chain's state and everything about HAVING one: init (with its retry), the config poll, availability rechecks, and the routing rewrite loop. The chain constructs one, asks it getState() on every call, and disposes it. */\nexport class ChainStateManager {\n    public readonly configured: RemoteConfig;\n    /** The newest adopted config - what getDebugName and dispatch decisions read. Starts as the configured one and moves with every adoption. */\n    public activeConfig: RemoteConfig;\n    private statePromise: Promise<ChainState> | undefined;\n    // The resolved state, for synchronous access (getGetURLs) - always the newest adopted config, where statePromise may briefly lag during a rebuild\n    private latestState: ChainState | undefined;\n    private initRetryDelay = RETRY_START_DELAY;\n    private initRetryTimer: ReturnType<typeof setTimeout> | undefined;\n    private pollTimer: ReturnType<typeof setInterval> | undefined;\n    private disposed = false;\n    private unsubscribeRoutingPush: (() => void) | undefined;\n    private routingRewriter: RoutingRewriteLoop;\n\n    constructor(private config: {\n        configured: RemoteConfig;\n        debugName: () => string;\n        /** See ArchivesChainOptions.directConnect. */\n        directConnect?: boolean;\n    }) {\n        this.configured = config.configured;\n        this.activeConfig = config.configured;\n        this.routingRewriter = new RoutingRewriteLoop({\n            configured: config.configured,\n            debugName: config.debugName,\n            latest: () => this.latestState,\n        });\n        this.unsubscribeRoutingPush = onServerRoutingChanged(() => {\n            void this.refreshActiveConfig().catch((e: Error) => console.error(`Config refresh failed for ${this.config.debugName()}: ${e.stack ?? e}`));\n        });\n    }\n\n    /** The newest adopted state, synchronously - undefined until the first init finishes. */\n    public latest(): ChainState | undefined {\n        return this.latestState;\n    }\n\n    public getState(): Promise<ChainState> {\n        if (this.disposed) {\n            return Promise.reject(new Error(`ArchivesChain ${this.config.debugName()} has been disposed`));\n        }\n        if (!this.statePromise) {\n            let promise = this.init();\n            this.statePromise = promise;\n            promise.then(() => {\n                this.initRetryDelay = RETRY_START_DELAY;\n            }, (e: Error) => {\n                if (this.disposed || this.initRetryTimer) return;\n                console.error(`Storage init failed for ${this.config.debugName()}, retrying in ${Math.round(this.initRetryDelay / 1000)}s. ${e.stack ?? e}`);\n                this.initRetryTimer = setTimeout(() => {\n                    this.initRetryTimer = undefined;\n                    if (this.disposed) return;\n                    if (this.statePromise === promise) {\n                        this.statePromise = undefined;\n                    }\n                    this.getState().catch(() => { });\n                }, this.initRetryDelay);\n                (this.initRetryTimer as { unref?: () => void }).unref?.();\n                this.initRetryDelay = Math.min(RETRY_MAX_DELAY, this.initRetryDelay * RETRY_GROWTH);\n            });\n        }\n        return this.statePromise;\n    }\n\n    private async init(): Promise<ChainState> {\n        let configs = this.configured.sources.map(normalizeSource);\n        let readOnly = this.isReadOnly(this.configured);\n        let probes = await probeSources(configs, readOnly);\n        try {\n            let { active, needsWrite, existing } = chooseStartupConfig({ configured: this.configured, probes, debugName: this.config.debugName() });\n            let sources = await this.buildSources(active);\n            let configWriteFailed = false;\n            if (needsWrite) {\n                console.log(`Storage routing config for ${this.config.debugName()} is out of date (stored version ${existing && getConfigVersion(existing) || \"none\"}, ours ${getConfigVersion(this.configured)})`);\n                let { failures, total } = await writeRoutingToAllStores({ configured: this.configured, sources, debugName: this.config.debugName() });\n                configWriteFailed = failures.length > 0;\n                if (failures.length && failures.length === total) {\n                    // Nobody has our config, so running on it would just disagree with every server. The stored one (when there is one) is what the servers actually run.\n                    console.error(`The storage routing config for ${this.config.debugName()} (version ${getConfigVersion(this.configured)}) could not be written to ANY of the ${total} stores. ${existing && `Running on the stored config (version ${getConfigVersion(existing)}) until a write succeeds.` || `No stored config exists either, so servers will reject writes until this succeeds.`} Retrying in ${CONFIG_WRITE_RETRY_INTERVAL / 1000}s. Failures: ${failures.join(\" | \")}`);\n                    if (existing) {\n                        active = existing;\n                        for (let source of sources) {\n                            source.dispose();\n                        }\n                        sources = await this.buildSources(active);\n                    }\n                } else if (failures.length) {\n                    console.error(`The storage routing config for ${this.config.debugName()} (version ${getConfigVersion(this.configured)}) was written to ${total - failures.length} of ${total} stores. Retrying the rest in ${CONFIG_WRITE_RETRY_INTERVAL / 1000}s (they also pull it from the stores that have it). Failures: ${failures.join(\" | \")}`);\n                }\n            }\n            for (let source of sources) {\n                let probe = probes.find(x => x.responded && x.sourceConfig.url === source.config.url);\n                if (probe) {\n                    source.seedLatency(probe.latency);\n                }\n            }\n            this.activeConfig = active;\n            this.startConfigPoll();\n            let state: ChainState = { config: active, sources };\n            this.latestState = state;\n            this.routingRewriter.start(configWriteFailed);\n            return state;\n        } finally {\n            disposeProbes(probes);\n        }\n    }\n\n    /** Clientside, a config with public sources is served entirely over plain URL downloads - no API connection, no access grant, and no writing. directConnect opts out of that. */\n    private isReadOnly(config: RemoteConfig): boolean {\n        if (this.config.directConnect || isNode()) return false;\n        return config.sources.map(normalizeSource).some(x => x.public);\n    }\n\n    private async createChainSource(sourceConfig: SourceConfig, readOnly: boolean): Promise<SourceWrapper> {\n        let source = await SourceWrapper.create(sourceConfig, { readOnly });\n        source.startPinging();\n        return source;\n    }\n\n    private async buildSources(config: RemoteConfig): Promise<SourceWrapper[]> {\n        let readOnly = this.isReadOnly(config);\n        let sources: SourceWrapper[] = [];\n        for (let sourceConfig of config.sources.map(normalizeSource)) {\n            sources.push(await this.createChainSource(sourceConfig, readOnly));\n        }\n        return sources;\n    }\n\n    private startConfigPoll(): void {\n        if (this.pollTimer || this.disposed) return;\n        this.pollTimer = setInterval(() => {\n            void this.refreshActiveConfig().catch((e: Error) => {\n                console.error(`Checking for a new storage routing config failed for ${this.config.debugName()}: ${e.stack ?? e}`);\n            });\n        }, CONFIG_POLL_INTERVAL);\n        (this.pollTimer as { unref?: () => void }).unref?.();\n    }\n\n    // Deduplicates concurrent refreshes (the poll timer and wrong-target write retries share this)\n    private configRefreshInFlight: Promise<void> | undefined;\n    public refreshActiveConfig(): Promise<void> {\n        if (!this.configRefreshInFlight) {\n            this.configRefreshInFlight = this.checkForNewConfig().finally(() => {\n                this.configRefreshInFlight = undefined;\n            });\n        }\n        return this.configRefreshInFlight;\n    }\n\n    private async fetchLatestConfig(state: ChainState): Promise<RemoteConfig | undefined> {\n        let errors: string[] = [];\n        for (let source of state.sources) {\n            try {\n                let latest = await source.readRoutingConfig();\n                if (latest) return normalizeRemoteConfig(latest);\n            } catch (e) {\n                errors.push(`${source.config.url}: ${(e as Error).stack ?? e}`);\n            }\n        }\n        if (errors.length === state.sources.length) {\n            throw new Error(`No storage source could give us the routing config for ${this.config.debugName()}: ${errors.join(\" | \")}`);\n        }\n        return undefined;\n    }\n\n    private async checkForNewConfig(): Promise<void> {\n        if (this.disposed || !this.statePromise) return;\n        let state: ChainState;\n        try {\n            state = await this.statePromise;\n        } catch {\n            return;\n        }\n        let latest = await this.fetchLatestConfig(state);\n        if (!latest) return;\n        await this.adoptNewConfig(state, latest);\n    }\n\n    private async adoptNewConfig(state: ChainState, latest: RemoteConfig): Promise<void> {\n        if (JSON.stringify(latest) === JSON.stringify(state.config)) return;\n        let received = new Date().toISOString();\n        let onlyIntermediatesChanged = JSON.stringify(resolveIntermediateSources(latest)) === JSON.stringify(resolveIntermediateSources(state.config));\n        if (onlyIntermediatesChanged) {\n            console.log(`Storage routing switchover windows changed (version ${getConfigVersion(state.config)} -> ${getConfigVersion(latest)}), received ${received}, rebuilding sources. New config: ${JSON.stringify(latest)}`);\n        } else {\n            console.log(`Storage routing config changed (version ${getConfigVersion(state.config)} -> ${getConfigVersion(latest)}), received ${received}, rebuilding sources. New config: ${JSON.stringify(latest)}`);\n        }\n        let strippedKey = (config: SourceConfig) => JSON.stringify({ ...config, validWindow: undefined });\n        let oldByConfig = new Map<string, SourceWrapper[]>();\n        for (let source of state.sources) {\n            let key = strippedKey(source.config);\n            let list = oldByConfig.get(key);\n            if (!list) {\n                list = [];\n                oldByConfig.set(key, list);\n            }\n            list.push(source);\n        }\n        let readOnly = this.isReadOnly(latest);\n        let sources: SourceWrapper[] = [];\n        for (let sourceConfig of latest.sources.map(normalizeSource)) {\n            let old = oldByConfig.get(strippedKey(sourceConfig))?.shift();\n            if (old) {\n                old.updateValidWindow(sourceConfig.validWindow);\n                sources.push(old);\n            } else {\n                sources.push(await this.createChainSource(sourceConfig, readOnly));\n            }\n        }\n        for (let leftovers of oldByConfig.values()) {\n            for (let leftover of leftovers) {\n                leftover.dispose();\n            }\n        }\n        this.activeConfig = latest;\n        let newState: ChainState = { config: latest, sources };\n        this.latestState = newState;\n        this.statePromise = Promise.resolve(newState);\n    }\n\n    private lastAvailabilityRecheck = 0;\n    private availabilityRecheckInFlight: Promise<void> | undefined;\n    /** Every source failed: re-contact all of them (routing re-read + connection re-attempt) and adopt whatever config comes back. Throttled, and deduplicated across concurrent callers. */\n    public recheckAvailability(): Promise<void> {\n        if (this.availabilityRecheckInFlight) return this.availabilityRecheckInFlight;\n        if (Date.now() - this.lastAvailabilityRecheck < AVAILABILITY_RECHECK_THROTTLE) return Promise.resolve();\n        this.lastAvailabilityRecheck = Date.now();\n        this.availabilityRecheckInFlight = this.recheckAvailabilityNow().finally(() => {\n            this.availabilityRecheckInFlight = undefined;\n        });\n        return this.availabilityRecheckInFlight;\n    }\n    private async recheckAvailabilityNow(): Promise<void> {\n        if (this.disposed || !this.statePromise) return;\n        let state: ChainState;\n        try {\n            state = await this.statePromise;\n        } catch {\n            return;\n        }\n        console.log(`Every storage source failed for ${this.config.debugName()}; re-contacting all ${state.sources.length} sources (routing re-read + connection re-attempt)`);\n        let results = await Promise.all(state.sources.map(async source => {\n            try {\n                return await source.readRoutingConfig();\n            } catch {\n                return undefined;\n            }\n        }));\n        let latest = results.find(x => x);\n        if (!latest) return;\n        await this.adoptNewConfig(state, latest);\n    }\n\n    public dispose(): void {\n        this.disposed = true;\n        this.unsubscribeRoutingPush?.();\n        if (this.pollTimer) {\n            clearInterval(this.pollTimer);\n        }\n        if (this.initRetryTimer) {\n            clearTimeout(this.initRetryTimer);\n        }\n        this.routingRewriter.dispose();\n        let statePromise = this.statePromise;\n        if (statePromise) {\n            void statePromise.then(state => {\n                for (let source of state.sources) {\n                    source.dispose();\n                }\n            }, () => { });\n        }\n    }\n}\n\nexport type SourceProbe = {\n    probe: SourceWrapper;\n    sourceConfig: SourceConfig;\n    responded: boolean;\n    latency: number;\n    existing: RemoteConfig | undefined;\n    error: string;\n};\n\n/** One throwaway SourceWrapper per configured source, each asked for its stored routing config - which also measures first-contact latency, seeded into the real sources afterwards. The probes MUST be disposed (disposeProbes) once the caller is done with them. */\nexport async function probeSources(configs: SourceConfig[], readOnly: boolean): Promise<SourceProbe[]> {\n    return await Promise.all(configs.map(async sourceConfig => {\n        let probe = await SourceWrapper.create(sourceConfig, { background: false, readOnly });\n        let start = Date.now();\n        try {\n            let existing = await probe.readRoutingConfig();\n            return { probe, sourceConfig, responded: true, latency: Date.now() - start, existing, error: \"\" };\n        } catch (e) {\n            return { probe, sourceConfig, responded: false, latency: 0, existing: undefined, error: `${sourceConfig.url}: ${(e as Error).stack ?? e}` };\n        }\n    }));\n}\n\nexport function disposeProbes(probes: SourceProbe[]): void {\n    for (let probe of probes) {\n        probe.probe.dispose();\n    }\n}\n\n/**\n * Which routing config the chain should RUN: the newest of ours and every stored one. needsWrite\n * when ours is strictly the newest, meaning the stores have to be told about it. A stored config\n * with our exact version but DIFFERENT content wins without a write, loudly: config updates must\n * bump the version, or they are ignored - silently taking the changed one would make \"what is the\n * bucket running\" depend on which process started last.\n *\n * Throws when no source answered at all: with nothing stored and nobody to write to, there is no\n * config to run.\n */\nexport function chooseStartupConfig(config: { configured: RemoteConfig; probes: SourceProbe[]; debugName: string }): { active: RemoteConfig; needsWrite: boolean; existing: RemoteConfig | undefined } {\n    let { configured, probes, debugName } = config;\n    let found = probes.find(x => x.responded);\n    if (!found) {\n        throw new Error(`Cannot initialize storage for ${debugName}: no source answered. ${probes.map(x => x.error).join(\" | \")}`);\n    }\n    let existing = found.existing;\n    let active = configured;\n    let needsWrite = true;\n    if (existing && getConfigVersion(existing) >= getConfigVersion(configured)) {\n        if (getConfigVersion(existing) === getConfigVersion(configured) && JSON.stringify(existing) !== JSON.stringify(configured)) {\n            console.error(`Archives configuration updated without updating the version, for ${found.sourceConfig.url}. Updates will be ignored until you increase the version. Using: ${JSON.stringify(existing)}, ignoring: ${JSON.stringify(configured)}`);\n        }\n        active = existing;\n        needsWrite = false;\n    }\n    if (needsWrite) {\n        let best: RemoteConfig | undefined;\n        let conflictUrl: string | undefined;\n        for (let probe of probes) {\n            let stored = probe.existing;\n            if (!stored) continue;\n            if (!best || getConfigVersion(stored) > getConfigVersion(best)) {\n                best = stored;\n            }\n            if (getConfigVersion(stored) === getConfigVersion(configured) && JSON.stringify(stored) !== JSON.stringify(configured)) {\n                conflictUrl = probe.sourceConfig.url;\n            }\n        }\n        if (best && getConfigVersion(best) >= getConfigVersion(configured)) {\n            if (conflictUrl && getConfigVersion(best) === getConfigVersion(configured)) {\n                console.error(`Archives configuration updated without updating the version, for ${conflictUrl}. Updates will be ignored until you increase the version. Using: ${JSON.stringify(best)}, ignoring: ${JSON.stringify(configured)}`);\n            }\n            active = best;\n            needsWrite = false;\n        }\n    }\n    return { active, needsWrite, existing };\n}\n\n/**\n * Writes the given routing config to every configured store, one write per url+name: the write\n * lands in the store the entry NAMES, so two entries sharing a URL but naming different stores are\n * two separate deliveries - deduping by URL alone leaves the second store unconfigured forever. All\n * in parallel, every failure tolerated (no-write-access included - the attempt classifies it,\n * nothing pre-checks it): a down node must not stop the others from getting the config - they would\n * then reject writes as unconfigured precisely BECAUSE it never arrived - and it must never stop\n * the chain from starting. A store that missed it pulls it off its peers, and the rewrite loop\n * tries again (see RoutingRewriteLoop).\n */\nexport async function writeRoutingToAllStores(config: { configured: RemoteConfig; sources: SourceWrapper[]; debugName: string }): Promise<{ failures: string[]; total: number }> {\n    let { configured, sources, debugName } = config;\n    let routingData = serializeRemoteConfig(configured);\n    let routingWriteTime = Date.now();\n    let targets: SourceWrapper[] = [];\n    let seen = new Set<string>();\n    for (let source of sources) {\n        let key = `${source.config.url}|${source.config.name}`;\n        if (seen.has(key)) continue;\n        seen.add(key);\n        targets.push(source);\n    }\n    console.log(`Writing routing config version ${getConfigVersion(configured)} for ${debugName} to all ${targets.length} stores (write time ${new Date(routingWriteTime).toISOString()}): ${targets.map(x => `${x.config.url} (store ${JSON.stringify(x.config.name)})`).join(\", \")}`);\n    let failures: string[] = [];\n    await Promise.all(targets.map(async source => {\n        try {\n            await source.write(archives => archives.set(ROUTING_FILE, routingData, { lastModified: routingWriteTime }));\n            console.log(`Wrote storage routing config version ${getConfigVersion(configured)} to ${source.config.url} (store ${JSON.stringify(source.config.name)})`);\n        } catch (e) {\n            failures.push(`${source.config.url} (store ${JSON.stringify(source.config.name)}): ${(e as Error).stack ?? e}`);\n        }\n    }));\n    return { failures, total: targets.length };\n}\n\n/**\n * The periodic re-write of the chain's in-code config: failures retried on the short interval - a\n * store without the config rejects every write aimed at it, so this not landing is a big deal,\n * logged on every attempt - and even success repeated hourly, in case a store lost it. The failure\n * this exists for: a server whose trust was only granted AFTER startup, so the startup write was\n * rejected and nothing else would ever retry it.\n */\nexport class RoutingRewriteLoop {\n    constructor(private config: {\n        configured: RemoteConfig;\n        debugName: () => string;\n        /** The chain's newest adopted state: what decides whether ours is still the config to write, and the sources it is written through. Undefined until the first init finishes. */\n        latest: () => { config: RemoteConfig; sources: SourceWrapper[] } | undefined;\n    }) { }\n\n    private timer: ReturnType<typeof setTimeout> | undefined;\n    private disposed = false;\n\n    /** (Re)arms the loop - called at the end of every init, with whether that init's write failed (which picks the short retry interval). */\n    public start(failedAtStartup: boolean): void {\n        this.schedule(failedAtStartup && CONFIG_WRITE_RETRY_INTERVAL || CONFIG_WRITE_REFRESH_INTERVAL);\n    }\n\n    public dispose(): void {\n        this.disposed = true;\n        if (this.timer) {\n            clearTimeout(this.timer);\n        }\n    }\n\n    private schedule(delay: number): void {\n        if (this.disposed) return;\n        if (this.timer) {\n            clearTimeout(this.timer);\n        }\n        this.timer = setTimeout(() => {\n            this.timer = undefined;\n            void this.rewrite().catch((e: Error) => {\n                console.error(`Rewriting the storage routing config for ${this.config.debugName()} failed: ${e.stack ?? e}`);\n                this.schedule(CONFIG_WRITE_RETRY_INTERVAL);\n            });\n        }, delay);\n        (this.timer as { unref?: () => void }).unref?.();\n    }\n\n    private async rewrite(): Promise<void> {\n        if (this.disposed) return;\n        let configured = this.config.configured;\n        let state = this.config.latest();\n        if (!state) {\n            this.schedule(CONFIG_WRITE_RETRY_INTERVAL);\n            return;\n        }\n        // The bucket adopted a NEWER config than our in-code one, so ours is stale and every store would (rightly) refuse it\n        if (getConfigVersion(state.config) > getConfigVersion(configured)) {\n            this.schedule(CONFIG_WRITE_REFRESH_INTERVAL);\n            return;\n        }\n        // Same version but different content: startup already decided the stored one wins until the version is bumped (see chooseStartupConfig), and re-writing ours would flip the bucket back and forth between the two\n        if (getConfigVersion(state.config) === getConfigVersion(configured) && JSON.stringify(state.config) !== JSON.stringify(configured)) {\n            this.schedule(CONFIG_WRITE_REFRESH_INTERVAL);\n            return;\n        }\n        let { failures, total } = await writeRoutingToAllStores({ configured, sources: state.sources, debugName: this.config.debugName() });\n        if (failures.length) {\n            console.error(`The periodic routing config write for ${this.config.debugName()} (version ${getConfigVersion(configured)}) failed on ${failures.length} of ${total} stores - retrying in ${CONFIG_WRITE_RETRY_INTERVAL / 1000}s: ${failures.join(\" | \")}`);\n            this.schedule(CONFIG_WRITE_RETRY_INTERVAL);\n            return;\n        }\n        this.schedule(CONFIG_WRITE_REFRESH_INTERVAL);\n    }\n}\n"]}
+ /* _JS_SOURCE_HASH = "d36ce7c1c47d19c7a2c75d2ec689971b811cf13f66d47cb04f742490229aa5d8"; */