sliftutils 1.7.9 → 1.7.11

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

@@ -0,0 +1,610 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.createArchives = exports.ArchivesChain = exports.createApiArchives = void 0;
+module.allowclient = true;
+const misc_1 = require("socket-function/src/misc");
+const IArchives_1 = require("../IArchives");
+const remoteConfig_1 = require("./remoteConfig");
+const ArchivesRemote_1 = require("./ArchivesRemote");
+const backblaze_1 = require("../backblaze");
+const storageServerState_1 = require("./storageServerState");
+const sourceWrapper_1 = require("./sourceWrapper");
+// Turns a RemoteConfig into a usable IArchives (createArchives). Initialization is lazy: on the
+// first call we walk the sources IN ORDER and the first one that answers is authoritative (sources
+// are synchronized copies of the same bucket, so we never consult the rest). Its stored routing
+// config wins over the in-memory one - unless ours has a strictly newer version, in which case we
+// write ours (creating the bucket when no routing exists at all). A failed init (all sources down,
+// or the routing write was rejected) stays failed for callers but retries itself in the background
+// with a ramping delay. Once running, we re-read the routing config every CONFIG_POLL_INTERVAL and
+// rebuild the source list when it changed (reusing wrappers for unchanged sources).
+const CONFIG_POLL_INTERVAL = 5 * 60 * 1000;
+// The direct API IArchives for one source, with no URL-form fallback and no chaining. Used by the
+// storage server for its synchronization sources. Denied calls throw immediately (registering the
+// access request in the background): the sync loops retry-and-log until access is granted, while
+// explicit writes surface the denial (with grant instructions) to the caller instead of hanging.
+function createApiArchives(source) {
+    if (source.type === "backblaze") {
+        return new backblaze_1.ArchivesBackblaze({ bucketName: (0, remoteConfig_1.parseBackblazeUrl)(source.url).bucketName, public: source.public, immutable: source.immutable });
+    }
+    let parsed = (0, remoteConfig_1.parseHostedUrl)(source.url);
+    let server = (0, misc_1.isNode)() && (0, storageServerState_1.getStorageServerConfigOptional)() || undefined;
+    if (server && parsed.address === server.domain && parsed.port === server.port) {
+        // This source is a bucket hosted by our own process - use it directly instead of calling
+        // ourselves over HTTPS
+        return (0, storageServerState_1.getLocalArchives)(parsed.account, parsed.bucketName);
+    }
+    return new ArchivesRemote_1.ArchivesRemote({ url: source.url, accountName: source.accountName, waitForAccess: false });
+}
+exports.createApiArchives = createApiArchives;
+function configWindowCurrent(config) {
+    let now = Date.now();
+    let [start, end] = config.validWindow;
+    return start - IArchives_1.WRITE_PAST_WINDOW_GRACE <= now && now <= end + IArchives_1.WRITE_PAST_WINDOW_GRACE;
+}
+// Client writes target only the CURRENTLY valid source: a future-window source receives its data
+// through server-side downstream propagation/backfill, never directly from clients
+function configAcceptsWrites(config) {
+    return configWindowCurrent(config);
+}
+class ArchivesChain {
+    constructor(config) {
+        this.initRetryDelay = sourceWrapper_1.RETRY_START_DELAY;
+        this.disposed = false;
+        this.configured = (0, remoteConfig_1.normalizeRemoteConfig)(config);
+        this.activeConfig = this.configured;
+    }
+    getDebugName() {
+        let urls = this.activeConfig.sources.map(x => typeof x === "string" && x || x.url);
+        return `chain/${urls.join(",")}`;
+    }
+    // Lazy init that rethrows its error to every caller, while a background timer resets and
+    // retries it with a ramping delay - so a chain that couldn't initialize fixes itself once a
+    // source comes back, without any caller having to drive it.
+    getState() {
+        if (this.disposed) {
+            return Promise.reject(new Error(`ArchivesChain ${this.getDebugName()} 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.getDebugName()}, 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() {
+        var _a, _b;
+        let configs = this.configured.sources.map(remoteConfig_1.normalizeSource);
+        let probeErrors = [];
+        let found;
+        for (let sourceConfig of configs) {
+            let probe = await sourceWrapper_1.SourceWrapper.create(sourceConfig, { background: false });
+            try {
+                let data = await probe.read(archives => archives.get(remoteConfig_1.ROUTING_FILE));
+                found = { probe, existing: data && (0, remoteConfig_1.parseRoutingData)(data) || undefined };
+                break;
+            }
+            catch (e) {
+                probeErrors.push(`${sourceConfig.url}: ${(_a = e.stack) !== null && _a !== void 0 ? _a : e}`);
+                probe.dispose();
+            }
+        }
+        if (!found) {
+            throw new Error(`Cannot initialize storage for ${this.getDebugName()}: no source answered. ${probeErrors.join(" | ")}`);
+        }
+        let active = this.configured;
+        let { probe, existing } = found;
+        let needsWrite = true;
+        if (existing && (0, remoteConfig_1.getConfigVersion)(existing) >= (0, remoteConfig_1.getConfigVersion)(this.configured)) {
+            if ((0, remoteConfig_1.getConfigVersion)(existing) === (0, remoteConfig_1.getConfigVersion)(this.configured) && JSON.stringify(existing) !== JSON.stringify(this.configured)) {
+                console.error(`Archives configuration updated without updating the version, for ${probe.config.url}. Updates will be ignored until you increase the version. Using: ${JSON.stringify(existing)}, ignoring: ${JSON.stringify(this.configured)}`);
+            }
+            active = existing;
+            needsWrite = false;
+        }
+        let sources = await this.buildSources(active);
+        if (needsWrite) {
+            // We decided to write (ours is newer than the authoritative first-up source's, or no
+            // routing exists yet). The write goes to all sources, so now EVERY reachable source's
+            // stored routing is read, and the write is refused unless our version is strictly
+            // greater than all of them - a source already at (or past) our version means this
+            // version number is taken, and writing anyway would leave sources at the same version
+            // with different content, each rejecting the other's pushes forever.
+            let best;
+            let conflictUrl;
+            for (let source of sources) {
+                let data;
+                try {
+                    data = await source.read(archives => archives.get(remoteConfig_1.ROUTING_FILE));
+                }
+                catch (_c) {
+                    // Down sources are still protected by the server-side version guard when the
+                    // write eventually reaches them
+                    continue;
+                }
+                if (!data)
+                    continue;
+                let stored = (0, remoteConfig_1.parseRoutingData)(data);
+                if (!best || (0, remoteConfig_1.getConfigVersion)(stored) > (0, remoteConfig_1.getConfigVersion)(best)) {
+                    best = stored;
+                }
+                if ((0, remoteConfig_1.getConfigVersion)(stored) === (0, remoteConfig_1.getConfigVersion)(this.configured) && JSON.stringify(stored) !== JSON.stringify(this.configured)) {
+                    conflictUrl = source.config.url;
+                }
+            }
+            if (best && (0, remoteConfig_1.getConfigVersion)(best) >= (0, remoteConfig_1.getConfigVersion)(this.configured)) {
+                if (conflictUrl && (0, remoteConfig_1.getConfigVersion)(best) === (0, remoteConfig_1.getConfigVersion)(this.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(this.configured)}`);
+                }
+                active = best;
+                needsWrite = false;
+                for (let source of sources) {
+                    source.dispose();
+                }
+                sources = await this.buildSources(active);
+            }
+        }
+        if (needsWrite) {
+            // The update only happens when EVERY source would accept it - a partial update would
+            // leave the sources out of sync, and a client without access retrying the write forever
+            // would never initialize. Without full access we run on the stored config (when there
+            // is one) and log the problem instead.
+            let missing = [];
+            for (let source of sources) {
+                try {
+                    if (!await source.hasWriteAccess()) {
+                        missing.push(source.config.url);
+                    }
+                }
+                catch (e) {
+                    missing.push(`${source.config.url} (check failed: ${(_b = e.stack) !== null && _b !== void 0 ? _b : e})`);
+                }
+            }
+            if (missing.length) {
+                console.error(`Not writing the storage routing config for ${this.getDebugName()} (version ${(0, remoteConfig_1.getConfigVersion)(this.configured)}): no write access to ${missing.join(", ")}. ${existing && `Running on the stored config (version ${(0, remoteConfig_1.getConfigVersion)(existing)}) instead.` || `No stored config exists, so the bucket cannot be created until write access is granted.`}`);
+                if (existing) {
+                    active = existing;
+                    for (let source of sources) {
+                        source.dispose();
+                    }
+                    sources = await this.buildSources(active);
+                }
+            }
+            else {
+                try {
+                    // A rejected write fails init, which retries from scratch - re-reading the
+                    // routing, so losing a create race to another client just adopts their config
+                    // on the next attempt.
+                    await probe.write(archives => archives.set(remoteConfig_1.ROUTING_FILE, (0, remoteConfig_1.serializeRemoteConfig)(this.configured)));
+                }
+                catch (e) {
+                    for (let source of sources) {
+                        source.dispose();
+                    }
+                    probe.dispose();
+                    throw e;
+                }
+            }
+        }
+        probe.dispose();
+        this.activeConfig = active;
+        this.startConfigPoll();
+        return { config: active, sources };
+    }
+    async buildSources(config) {
+        let sources = [];
+        for (let sourceConfig of config.sources.map(remoteConfig_1.normalizeSource)) {
+            let source = await sourceWrapper_1.SourceWrapper.create(sourceConfig);
+            // Latency (for variable-shard target preference) is tracked from initialization on
+            source.startPinging();
+            sources.push(source);
+        }
+        return sources;
+    }
+    startConfigPoll() {
+        var _a, _b;
+        if (this.pollTimer || this.disposed)
+            return;
+        this.pollTimer = setInterval(() => {
+            void this.checkForNewConfig().catch((e) => {
+                var _a;
+                console.error(`Checking for a new storage routing config failed for ${this.getDebugName()}: ${(_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);
+    }
+    async checkForNewConfig() {
+        if (this.disposed || !this.statePromise)
+            return;
+        let state;
+        try {
+            state = await this.statePromise;
+        }
+        catch (_a) {
+            // Init is failing; its own retry loop handles that
+            return;
+        }
+        let data = await this.run(state, {}, archives => archives.get(remoteConfig_1.ROUTING_FILE));
+        if (!data)
+            return;
+        let latest = (0, remoteConfig_1.parseRoutingData)(data);
+        if (JSON.stringify(latest) === JSON.stringify(state.config))
+            return;
+        console.log(`Storage routing config changed for ${this.getDebugName()}, rebuilding sources`);
+        let oldByConfig = new Map(state.sources.map(source => [JSON.stringify(source.config), source]));
+        let sources = [];
+        for (let sourceConfig of latest.sources.map(remoteConfig_1.normalizeSource)) {
+            let key = JSON.stringify(sourceConfig);
+            let old = oldByConfig.get(key);
+            if (old) {
+                oldByConfig.delete(key);
+                sources.push(old);
+            }
+            else {
+                sources.push(await sourceWrapper_1.SourceWrapper.create(sourceConfig));
+            }
+        }
+        // In-flight requests still hold the old wrappers and finish fine; dispose just stops any
+        // background reconnect loops
+        for (let leftover of oldByConfig.values()) {
+            leftover.dispose();
+        }
+        this.activeConfig = latest;
+        this.statePromise = Promise.resolve({ config: latest, sources });
+    }
+    // Runs a request against the first available source (that covers the key's route, when one is
+    // given), moving to the next one ONLY when the source's WebSocket is down (checked directly -
+    // never by inspecting the error, which is arbitrary data). An error from a connected source is
+    // an application error and throws as-is. A down source gets its background reconnect kicked.
+    async run(state, config, run) {
+        var _a;
+        if (config.write) {
+            return await this.runWrite(state, config.route, run);
+        }
+        let errors = [];
+        for (let source of state.sources) {
+            if (config.route !== undefined && !(0, remoteConfig_1.routeContains)(source.config.route, config.route))
+                continue;
+            if (!configWindowCurrent(source.config))
+                continue;
+            if (!source.isConnected()) {
+                source.noteFailure();
+                errors.push(`${source.config.url} is not connected`);
+                continue;
+            }
+            try {
+                if (config.apiOnly) {
+                    let api = source.api;
+                    if (!api) {
+                        errors.push(`${source.config.url} has URL-only access, which cannot serve this operation`);
+                        continue;
+                    }
+                    return await run(api);
+                }
+                return await source.read(run);
+            }
+            catch (e) {
+                if (source.isConnected())
+                    throw e;
+                source.noteFailure();
+                errors.push(String((_a = e.stack) !== null && _a !== void 0 ? _a : e));
+            }
+        }
+        throw new Error(`All sources failed for ${this.getDebugName()}${config.route !== undefined && ` (route ${config.route})` || ""}: ${errors.join(" | ") || "no sources available"}`);
+    }
+    // Writes are consistent: they go to the first currently-valid source covering the key's route
+    // and NEVER fail over to another node - a client wrongly deciding nodes are down must not
+    // scatter its writes across the chain. (Reads fail over freely above: sources are synchronized
+    // copies, so reading from any of them is safe.) The one retry is for a window boundary passing
+    // (or a route disagreement) mid-write, which re-resolves the target rather than falling back.
+    async runWrite(state, route, run) {
+        var _a;
+        let retriedWrongWindow = false;
+        let retriedWrongRoute = false;
+        while (true) {
+            let target = state.sources.find(x => configAcceptsWrites(x.config) && (route === undefined || (0, remoteConfig_1.routeContains)(x.config.route, route)));
+            if (!target) {
+                throw new Error(`No source accepts writes for ${this.getDebugName()}${route !== undefined && ` (route ${route})` || ""} (every source is outside its valid window or outside the key's route)`);
+            }
+            if (!target.isConnected()) {
+                target.noteFailure();
+                throw new Error(`Cannot write: the write target ${target.config.url} is not connected (writes never fail over to other sources)`);
+            }
+            try {
+                return await target.write(run);
+            }
+            catch (e) {
+                let message = String((_a = e.stack) !== null && _a !== void 0 ? _a : e);
+                if (message.includes(IArchives_1.STORAGE_WRONG_VALID_WINDOW) && !retriedWrongWindow) {
+                    retriedWrongWindow = true;
+                    continue;
+                }
+                if (message.includes(IArchives_1.STORAGE_WRONG_ROUTE) && !retriedWrongRoute) {
+                    retriedWrongRoute = true;
+                    continue;
+                }
+                if (!target.isConnected()) {
+                    target.noteFailure();
+                }
+                throw e;
+            }
+        }
+    }
+    async request(config, run) {
+        let state = await this.getState();
+        return await this.run(state, config, run);
+    }
+    // The access-page link (plus our machineId/ip, for the approver to match the request) for the
+    // first hosted source that hasn't granted us access. undefined when we have access everywhere
+    // we can have it. Also registers the access request server-side.
+    async waitingForAccess() {
+        let state = await this.getState();
+        for (let source of state.sources) {
+            if (source.api instanceof ArchivesRemote_1.ArchivesRemote) {
+                let waiting = await source.api.waitingForAccess();
+                if (waiting)
+                    return waiting;
+            }
+        }
+        return undefined;
+    }
+    async get(fileName, config) {
+        let result = await this.get2(fileName, config);
+        return result && result.data || undefined;
+    }
+    async get2(fileName, config) {
+        return await this.request({ route: (0, remoteConfig_1.getRoute)(fileName) }, archives => archives.get2(fileName, config));
+    }
+    async getInfo(fileName) {
+        return await this.request({ route: (0, remoteConfig_1.getRoute)(fileName) }, archives => archives.getInfo(fileName));
+    }
+    // A minimal set of connected, currently-valid API sources whose routes cover [0, 1) - listing
+    // operations must merge every shard. Greedy sweep: repeatedly take the source that extends
+    // coverage the furthest. In practice this is one source (unsharded), or one per shard.
+    selectCoveringSources(state) {
+        let candidates = state.sources.filter(x => configWindowCurrent(x.config) && x.api && x.isConnected());
+        let chosen = [];
+        let covered = 0;
+        while (covered < 1) {
+            let best;
+            let bestEnd = covered;
+            for (let source of candidates) {
+                let [start, end] = source.config.route || IArchives_1.FULL_ROUTE;
+                if (start > covered)
+                    continue;
+                if (end > bestEnd) {
+                    bestEnd = end;
+                    best = source;
+                }
+            }
+            if (!best) {
+                throw new Error(`Cannot cover the full route space for ${this.getDebugName()}: the available sources only cover up to ${covered} (some shards are down or URL-only)`);
+            }
+            chosen.push(best);
+            covered = bestEnd;
+        }
+        return chosen;
+    }
+    async runOnApi(source, run) {
+        let api = source.api;
+        if (!api) {
+            throw new Error(`${source.config.url} has URL-only access, which cannot serve this operation`);
+        }
+        return await run(api);
+    }
+    async find(prefix, config) {
+        return (await this.findInfo(prefix, config)).map(x => x.path);
+    }
+    async findInfo(prefix, config) {
+        let state = await this.getState();
+        let covering = this.selectCoveringSources(state);
+        let results = await Promise.all(covering.map(source => this.runOnApi(source, archives => archives.findInfo(prefix, config))));
+        // Overlapping shards can both report a path; the newest wins
+        let byPath = new Map();
+        for (let list of results) {
+            for (let file of list) {
+                let existing = byPath.get(file.path);
+                if (!existing || file.createTime > existing.createTime) {
+                    byPath.set(file.path, file);
+                }
+            }
+        }
+        let merged = [...byPath.values()];
+        (0, misc_1.sort)(merged, x => x.path);
+        return merged;
+    }
+    async getChangesAfter(time) {
+        let state = await this.getState();
+        let covering = this.selectCoveringSources(state);
+        let results = await Promise.all(covering.map(source => this.runOnApi(source, async (archives) => {
+            if (!archives.getChangesAfter) {
+                throw new Error(`${archives.getDebugName()} does not support getChangesAfter`);
+            }
+            return await archives.getChangesAfter(time);
+        })));
+        let byPath = new Map();
+        for (let list of results) {
+            for (let file of list) {
+                let existing = byPath.get(file.path);
+                if (!existing || file.createTime > existing.createTime) {
+                    byPath.set(file.path, file);
+                }
+            }
+        }
+        let merged = [...byPath.values()];
+        (0, misc_1.sort)(merged, x => x.path);
+        return merged;
+    }
+    async getSyncStatus() {
+        let state = await this.getState();
+        let covering = this.selectCoveringSources(state);
+        let statuses = await Promise.all(covering.map(source => this.runOnApi(source, async (archives) => {
+            if (!archives.getSyncStatus) {
+                throw new Error(`${archives.getDebugName()} does not support getSyncStatus`);
+            }
+            return await archives.getSyncStatus();
+        })));
+        return {
+            allScansComplete: statuses.every(x => x.allScansComplete),
+            indexSize: statuses.reduce((sum, x) => sum + x.indexSize, 0),
+            sources: statuses.flatMap(x => x.sources),
+        };
+    }
+    async getConfig() {
+        let state = await this.getState();
+        if (!state.sources.some(x => x.api))
+            return { remoteConfig: state.config };
+        let config = await this.run(state, { apiOnly: true }, archives => archives.getConfig());
+        return { ...config, remoteConfig: state.config };
+    }
+    /** True only when EVERY write-receiving source would accept our writes (partial write access
+     *  desynchronizes sources, so it counts as no access). */
+    async hasWriteAccess() {
+        let state = await this.getState();
+        for (let source of state.sources) {
+            if (!configAcceptsWrites(source.config))
+                continue;
+            if (!await source.hasWriteAccess())
+                return false;
+        }
+        return true;
+    }
+    assertNotBareVariableShard(fileName) {
+        if (fileName.includes(IArchives_1.VARIABLE_SHARD) && (0, remoteConfig_1.parseVariableRoute)(fileName) === undefined) {
+            throw new Error(`Keys containing VARIABLE_SHARD must be written with setVariableShard, which materializes the shard value and returns the full key. Key: ${JSON.stringify(fileName)}`);
+        }
+    }
+    async set(fileName, data, config) {
+        this.assertNotBareVariableShard(fileName);
+        await this.request({ write: true, route: (0, remoteConfig_1.getRoute)(fileName) }, archives => archives.set(fileName, data, config));
+    }
+    async del(fileName) {
+        await this.request({ write: true, route: (0, remoteConfig_1.getRoute)(fileName) }, archives => archives.del(fileName));
+    }
+    /** Writes a key containing the VARIABLE_SHARD sentinel: picks the lowest-latency up write
+     *  shard, materializes the key with a random value inside that shard's route, writes it, and
+     *  returns the FULL key actually written (the caller needs it to ever read the value back).
+     *  Unlike normal writes this CAN move to another shard when the preferred one is down (error +
+     *  socket down, same rule as reads) - each shard receives a different key, so write
+     *  consistency is preserved. */
+    async setVariableShard(key, data, config) {
+        var _a;
+        if (!key.includes(IArchives_1.VARIABLE_SHARD)) {
+            throw new Error(`Expected the key to contain the VARIABLE_SHARD sentinel, was ${JSON.stringify(key)}`);
+        }
+        if ((0, remoteConfig_1.parseVariableRoute)(key) !== undefined) {
+            throw new Error(`The key already has a materialized shard value; write it with set instead. Key: ${JSON.stringify(key)}`);
+        }
+        let state = await this.getState();
+        // Per-shard write consistency still holds: within a route, only the FIRST source may take
+        // writes - latency only picks WHICH shard the key materializes into
+        let targetsByRoute = new Map();
+        for (let source of state.sources) {
+            if (!configAcceptsWrites(source.config))
+                continue;
+            let routeKey = JSON.stringify(source.config.route || IArchives_1.FULL_ROUTE);
+            if (!targetsByRoute.has(routeKey)) {
+                targetsByRoute.set(routeKey, source);
+            }
+        }
+        let targets = [...targetsByRoute.values()];
+        (0, misc_1.sort)(targets, x => x.getLatency());
+        let errors = [];
+        for (let target of targets) {
+            if (!target.isConnected()) {
+                target.noteFailure();
+                errors.push(`${target.config.url} is not connected`);
+                continue;
+            }
+            let [start, end] = target.config.route || IArchives_1.FULL_ROUTE;
+            let fullKey = key.replace(IArchives_1.VARIABLE_SHARD, IArchives_1.VARIABLE_SHARD + "_" + (start + Math.random() * (end - start)));
+            try {
+                await target.write(archives => archives.set(fullKey, data, config));
+                return fullKey;
+            }
+            catch (e) {
+                // An error alone doesn't justify moving on (it would be an application error); the
+                // socket must also be down
+                if (target.isConnected())
+                    throw e;
+                target.noteFailure();
+                errors.push(String((_a = e.stack) !== null && _a !== void 0 ? _a : e));
+            }
+        }
+        throw new Error(`Every variable-shard write target failed for ${this.getDebugName()}: ${errors.join(" | ") || "no sources accept writes"}`);
+    }
+    async setLargeFile(config) {
+        this.assertNotBareVariableShard(config.path);
+        let state = await this.getState();
+        // Same consistency rule as runWrite: the first currently-valid source for the route, or nothing
+        let route = (0, remoteConfig_1.getRoute)(config.path);
+        let target = state.sources.find(x => configAcceptsWrites(x.config) && (0, remoteConfig_1.routeContains)(x.config.route, route));
+        if (!target) {
+            throw new Error(`No source accepts writes for setLargeFile on ${this.getDebugName()} (route ${route})`);
+        }
+        if (!target.isConnected()) {
+            target.noteFailure();
+            throw new Error(`Cannot write: the write target ${target.config.url} is not connected (writes never fail over to other sources)`);
+        }
+        await target.write(archives => archives.setLargeFile(config));
+    }
+    async getURL(path) {
+        let state = await this.getState();
+        let route = (0, remoteConfig_1.getRoute)(path);
+        for (let source of state.sources) {
+            if (source.config.public === false)
+                continue;
+            if (!(0, remoteConfig_1.routeContains)(source.config.route, route))
+                continue;
+            if (source.url)
+                return await source.url.getURL(path);
+            if (source.api)
+                return await source.api.getURL(path);
+        }
+        throw new Error(`No public source covering route ${route} to build a URL from for ${this.getDebugName()}`);
+    }
+    dispose() {
+        this.disposed = true;
+        if (this.pollTimer) {
+            clearInterval(this.pollTimer);
+        }
+        if (this.initRetryTimer) {
+            clearTimeout(this.initRetryTimer);
+        }
+        let statePromise = this.statePromise;
+        if (statePromise) {
+            void statePromise.then(state => {
+                for (let source of state.sources) {
+                    source.dispose();
+                }
+            }, () => { });
+        }
+    }
+}
+exports.ArchivesChain = ArchivesChain;
+// The IArchives for a RemoteConfig (or a single source - a routing URL string works). Fully lazy:
+// nothing is contacted until the first call. Call dispose() when done with it, so its background
+// retry/poll loops stop.
+function createArchives(config) {
+    return new ArchivesChain(config);
+}
+exports.createArchives = createArchives;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"createArchives.js","sourceRoot":"","sources":["createArchives.ts"],"names":[],"mappings":"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","sourcesContent":["module.allowclient = true;\n\nimport { isNode, sort } from \"socket-function/src/misc\";\nimport {\n    IArchives, RemoteConfig, RemoteConfigBase, HostedConfig, BackblazeConfig,\n    ArchiveFileInfo, ArchivesConfig, ArchivesSyncStatus, WRITE_PAST_WINDOW_GRACE, STORAGE_WRONG_VALID_WINDOW,\n    STORAGE_WRONG_ROUTE, FULL_ROUTE, VARIABLE_SHARD,\n} from \"../IArchives\";\nimport {\n    ROUTING_FILE, getConfigVersion, parseHostedUrl, parseBackblazeUrl,\n    normalizeRemoteConfig, normalizeSource, parseRoutingData, serializeRemoteConfig,\n    getRoute, routeContains, parseVariableRoute,\n} from \"./remoteConfig\";\nimport { ArchivesRemote } from \"./ArchivesRemote\";\nimport { ArchivesBackblaze } from \"../backblaze\";\nimport { getStorageServerConfigOptional, getLocalArchives } from \"./storageServerState\";\nimport { SourceWrapper, RETRY_START_DELAY, RETRY_MAX_DELAY, RETRY_GROWTH } from \"./sourceWrapper\";\n\n// Turns a RemoteConfig into a usable IArchives (createArchives). Initialization is lazy: on the\n// first call we walk the sources IN ORDER and the first one that answers is authoritative (sources\n// are synchronized copies of the same bucket, so we never consult the rest). Its stored routing\n// config wins over the in-memory one - unless ours has a strictly newer version, in which case we\n// write ours (creating the bucket when no routing exists at all). A failed init (all sources down,\n// or the routing write was rejected) stays failed for callers but retries itself in the background\n// with a ramping delay. Once running, we re-read the routing config every CONFIG_POLL_INTERVAL and\n// rebuild the source list when it changed (reusing wrappers for unchanged sources).\n\nconst CONFIG_POLL_INTERVAL = 5 * 60 * 1000;\n\n// The direct API IArchives for one source, with no URL-form fallback and no chaining. Used by the\n// storage server for its synchronization sources. Denied calls throw immediately (registering the\n// access request in the background): the sync loops retry-and-log until access is granted, while\n// explicit writes surface the denial (with grant instructions) to the caller instead of hanging.\nexport function createApiArchives(source: HostedConfig | BackblazeConfig): IArchives {\n    if (source.type === \"backblaze\") {\n        return new ArchivesBackblaze({ bucketName: parseBackblazeUrl(source.url).bucketName, public: source.public, immutable: source.immutable });\n    }\n    let parsed = parseHostedUrl(source.url);\n    let server = isNode() && getStorageServerConfigOptional() || undefined;\n    if (server && parsed.address === server.domain && parsed.port === server.port) {\n        // This source is a bucket hosted by our own process - use it directly instead of calling\n        // ourselves over HTTPS\n        return getLocalArchives(parsed.account, parsed.bucketName);\n    }\n    return new ArchivesRemote({ url: source.url, accountName: source.accountName, waitForAccess: false });\n}\n\ntype ChainState = {\n    config: RemoteConfig;\n    sources: SourceWrapper[];\n};\n\nfunction configWindowCurrent(config: HostedConfig | BackblazeConfig): boolean {\n    let now = Date.now();\n    let [start, end] = config.validWindow;\n    return start - WRITE_PAST_WINDOW_GRACE <= now && now <= end + WRITE_PAST_WINDOW_GRACE;\n}\n\n// Client writes target only the CURRENTLY valid source: a future-window source receives its data\n// through server-side downstream propagation/backfill, never directly from clients\nfunction configAcceptsWrites(config: HostedConfig | BackblazeConfig): boolean {\n    return configWindowCurrent(config);\n}\n\nexport class ArchivesChain implements IArchives {\n    private configured: RemoteConfig;\n    // The config we actually run on (the authoritative stored one after init)\n    private activeConfig: RemoteConfig;\n    private statePromise: Promise<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\n    constructor(config: RemoteConfig | RemoteConfigBase) {\n        this.configured = normalizeRemoteConfig(config);\n        this.activeConfig = this.configured;\n    }\n\n    public getDebugName() {\n        let urls = this.activeConfig.sources.map(x => typeof x === \"string\" && x || (x as HostedConfig | BackblazeConfig).url);\n        return `chain/${urls.join(\",\")}`;\n    }\n\n    // Lazy init that rethrows its error to every caller, while a background timer resets and\n    // retries it with a ramping delay - so a chain that couldn't initialize fixes itself once a\n    // source comes back, without any caller having to drive it.\n    private getState(): Promise<ChainState> {\n        if (this.disposed) {\n            return Promise.reject(new Error(`ArchivesChain ${this.getDebugName()} 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.getDebugName()}, 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 probeErrors: string[] = [];\n        let found: { probe: SourceWrapper; existing: RemoteConfig | undefined } | undefined;\n        for (let sourceConfig of configs) {\n            let probe = await SourceWrapper.create(sourceConfig, { background: false });\n            try {\n                let data = await probe.read(archives => archives.get(ROUTING_FILE));\n                found = { probe, existing: data && parseRoutingData(data) || undefined };\n                break;\n            } catch (e) {\n                probeErrors.push(`${sourceConfig.url}: ${(e as Error).stack ?? e}`);\n                probe.dispose();\n            }\n        }\n        if (!found) {\n            throw new Error(`Cannot initialize storage for ${this.getDebugName()}: no source answered. ${probeErrors.join(\" | \")}`);\n        }\n        let active = this.configured;\n        let { probe, existing } = found;\n        let needsWrite = true;\n        if (existing && getConfigVersion(existing) >= getConfigVersion(this.configured)) {\n            if (getConfigVersion(existing) === getConfigVersion(this.configured) && JSON.stringify(existing) !== JSON.stringify(this.configured)) {\n                console.error(`Archives configuration updated without updating the version, for ${probe.config.url}. Updates will be ignored until you increase the version. Using: ${JSON.stringify(existing)}, ignoring: ${JSON.stringify(this.configured)}`);\n            }\n            active = existing;\n            needsWrite = false;\n        }\n        let sources = await this.buildSources(active);\n        if (needsWrite) {\n            // We decided to write (ours is newer than the authoritative first-up source's, or no\n            // routing exists yet). The write goes to all sources, so now EVERY reachable source's\n            // stored routing is read, and the write is refused unless our version is strictly\n            // greater than all of them - a source already at (or past) our version means this\n            // version number is taken, and writing anyway would leave sources at the same version\n            // with different content, each rejecting the other's pushes forever.\n            let best: RemoteConfig | undefined;\n            let conflictUrl: string | undefined;\n            for (let source of sources) {\n                let data: Buffer | undefined;\n                try {\n                    data = await source.read(archives => archives.get(ROUTING_FILE));\n                } catch {\n                    // Down sources are still protected by the server-side version guard when the\n                    // write eventually reaches them\n                    continue;\n                }\n                if (!data) continue;\n                let stored = parseRoutingData(data);\n                if (!best || getConfigVersion(stored) > getConfigVersion(best)) {\n                    best = stored;\n                }\n                if (getConfigVersion(stored) === getConfigVersion(this.configured) && JSON.stringify(stored) !== JSON.stringify(this.configured)) {\n                    conflictUrl = source.config.url;\n                }\n            }\n            if (best && getConfigVersion(best) >= getConfigVersion(this.configured)) {\n                if (conflictUrl && getConfigVersion(best) === getConfigVersion(this.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(this.configured)}`);\n                }\n                active = best;\n                needsWrite = false;\n                for (let source of sources) {\n                    source.dispose();\n                }\n                sources = await this.buildSources(active);\n            }\n        }\n        if (needsWrite) {\n            // The update only happens when EVERY source would accept it - a partial update would\n            // leave the sources out of sync, and a client without access retrying the write forever\n            // would never initialize. Without full access we run on the stored config (when there\n            // is one) and log the problem instead.\n            let missing: string[] = [];\n            for (let source of sources) {\n                try {\n                    if (!await source.hasWriteAccess()) {\n                        missing.push(source.config.url);\n                    }\n                } catch (e) {\n                    missing.push(`${source.config.url} (check failed: ${(e as Error).stack ?? e})`);\n                }\n            }\n            if (missing.length) {\n                console.error(`Not writing the storage routing config for ${this.getDebugName()} (version ${getConfigVersion(this.configured)}): no write access to ${missing.join(\", \")}. ${existing && `Running on the stored config (version ${getConfigVersion(existing)}) instead.` || `No stored config exists, so the bucket cannot be created until write access is granted.`}`);\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 {\n                try {\n                    // A rejected write fails init, which retries from scratch - re-reading the\n                    // routing, so losing a create race to another client just adopts their config\n                    // on the next attempt.\n                    await probe.write(archives => archives.set(ROUTING_FILE, serializeRemoteConfig(this.configured)));\n                } catch (e) {\n                    for (let source of sources) {\n                        source.dispose();\n                    }\n                    probe.dispose();\n                    throw e;\n                }\n            }\n        }\n        probe.dispose();\n        this.activeConfig = active;\n        this.startConfigPoll();\n        return { config: active, sources };\n    }\n\n    private async buildSources(config: RemoteConfig): Promise<SourceWrapper[]> {\n        let sources: SourceWrapper[] = [];\n        for (let sourceConfig of config.sources.map(normalizeSource)) {\n            let source = await SourceWrapper.create(sourceConfig);\n            // Latency (for variable-shard target preference) is tracked from initialization on\n            source.startPinging();\n            sources.push(source);\n        }\n        return sources;\n    }\n\n    private startConfigPoll(): void {\n        if (this.pollTimer || this.disposed) return;\n        this.pollTimer = setInterval(() => {\n            void this.checkForNewConfig().catch((e: Error) => {\n                console.error(`Checking for a new storage routing config failed for ${this.getDebugName()}: ${e.stack ?? e}`);\n            });\n        }, CONFIG_POLL_INTERVAL);\n        (this.pollTimer as { unref?: () => void }).unref?.();\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            // Init is failing; its own retry loop handles that\n            return;\n        }\n        let data = await this.run(state, {}, archives => archives.get(ROUTING_FILE));\n        if (!data) return;\n        let latest = parseRoutingData(data);\n        if (JSON.stringify(latest) === JSON.stringify(state.config)) return;\n        console.log(`Storage routing config changed for ${this.getDebugName()}, rebuilding sources`);\n        let oldByConfig = new Map(state.sources.map(source => [JSON.stringify(source.config), source]));\n        let sources: SourceWrapper[] = [];\n        for (let sourceConfig of latest.sources.map(normalizeSource)) {\n            let key = JSON.stringify(sourceConfig);\n            let old = oldByConfig.get(key);\n            if (old) {\n                oldByConfig.delete(key);\n                sources.push(old);\n            } else {\n                sources.push(await SourceWrapper.create(sourceConfig));\n            }\n        }\n        // In-flight requests still hold the old wrappers and finish fine; dispose just stops any\n        // background reconnect loops\n        for (let leftover of oldByConfig.values()) {\n            leftover.dispose();\n        }\n        this.activeConfig = latest;\n        this.statePromise = Promise.resolve({ config: latest, sources });\n    }\n\n    // Runs a request against the first available source (that covers the key's route, when one is\n    // given), moving to the next one ONLY when the source's WebSocket is down (checked directly -\n    // never by inspecting the error, which is arbitrary data). An error from a connected source is\n    // an application error and throws as-is. A down source gets its background reconnect kicked.\n    private async run<T>(state: ChainState, config: { apiOnly?: boolean; write?: boolean; route?: number }, run: (archives: IArchives) => Promise<T>): Promise<T> {\n        if (config.write) {\n            return await this.runWrite(state, config.route, run);\n        }\n        let errors: string[] = [];\n        for (let source of state.sources) {\n            if (config.route !== undefined && !routeContains(source.config.route, config.route)) continue;\n            if (!configWindowCurrent(source.config)) continue;\n            if (!source.isConnected()) {\n                source.noteFailure();\n                errors.push(`${source.config.url} is not connected`);\n                continue;\n            }\n            try {\n                if (config.apiOnly) {\n                    let api = source.api;\n                    if (!api) {\n                        errors.push(`${source.config.url} has URL-only access, which cannot serve this operation`);\n                        continue;\n                    }\n                    return await run(api);\n                }\n                return await source.read(run);\n            } catch (e) {\n                if (source.isConnected()) throw e;\n                source.noteFailure();\n                errors.push(String((e as Error).stack ?? e));\n            }\n        }\n        throw new Error(`All sources failed for ${this.getDebugName()}${config.route !== undefined && ` (route ${config.route})` || \"\"}: ${errors.join(\" | \") || \"no sources available\"}`);\n    }\n\n    // Writes are consistent: they go to the first currently-valid source covering the key's route\n    // and NEVER fail over to another node - a client wrongly deciding nodes are down must not\n    // scatter its writes across the chain. (Reads fail over freely above: sources are synchronized\n    // copies, so reading from any of them is safe.) The one retry is for a window boundary passing\n    // (or a route disagreement) mid-write, which re-resolves the target rather than falling back.\n    private async runWrite<T>(state: ChainState, route: number | undefined, run: (archives: IArchives) => Promise<T>): Promise<T> {\n        let retriedWrongWindow = false;\n        let retriedWrongRoute = false;\n        while (true) {\n            let target = state.sources.find(x => configAcceptsWrites(x.config) && (route === undefined || routeContains(x.config.route, route)));\n            if (!target) {\n                throw new Error(`No source accepts writes for ${this.getDebugName()}${route !== undefined && ` (route ${route})` || \"\"} (every source is outside its valid window or outside the key's route)`);\n            }\n            if (!target.isConnected()) {\n                target.noteFailure();\n                throw new Error(`Cannot write: the write target ${target.config.url} is not connected (writes never fail over to other sources)`);\n            }\n            try {\n                return await target.write(run);\n            } catch (e) {\n                let message = String((e as Error).stack ?? e);\n                if (message.includes(STORAGE_WRONG_VALID_WINDOW) && !retriedWrongWindow) {\n                    retriedWrongWindow = true;\n                    continue;\n                }\n                if (message.includes(STORAGE_WRONG_ROUTE) && !retriedWrongRoute) {\n                    retriedWrongRoute = true;\n                    continue;\n                }\n                if (!target.isConnected()) {\n                    target.noteFailure();\n                }\n                throw e;\n            }\n        }\n    }\n\n    private async request<T>(config: { apiOnly?: boolean; write?: boolean; route?: number }, run: (archives: IArchives) => Promise<T>): Promise<T> {\n        let state = await this.getState();\n        return await this.run(state, config, run);\n    }\n\n    // The access-page link (plus our machineId/ip, for the approver to match the request) for the\n    // first hosted source that hasn't granted us access. undefined when we have access everywhere\n    // we can have it. Also registers the access request server-side.\n    public async waitingForAccess(): Promise<{ link: string; machineId: string; ip: string } | undefined> {\n        let state = await this.getState();\n        for (let source of state.sources) {\n            if (source.api instanceof ArchivesRemote) {\n                let waiting = await source.api.waitingForAccess();\n                if (waiting) return waiting;\n            }\n        }\n        return undefined;\n    }\n\n    public async get(fileName: string, config?: { range?: { start: number; end: number } }): Promise<Buffer | undefined> {\n        let result = await this.get2(fileName, config);\n        return result && result.data || undefined;\n    }\n    public async get2(fileName: string, config?: { range?: { start: number; end: number } }): Promise<{ data: Buffer; writeTime: number; size: number } | undefined> {\n        return await this.request({ route: getRoute(fileName) }, archives => archives.get2(fileName, config));\n    }\n    public async getInfo(fileName: string): Promise<{ writeTime: number; size: number } | undefined> {\n        return await this.request({ route: getRoute(fileName) }, archives => archives.getInfo(fileName));\n    }\n\n    // A minimal set of connected, currently-valid API sources whose routes cover [0, 1) - listing\n    // operations must merge every shard. Greedy sweep: repeatedly take the source that extends\n    // coverage the furthest. In practice this is one source (unsharded), or one per shard.\n    private selectCoveringSources(state: ChainState): SourceWrapper[] {\n        let candidates = state.sources.filter(x => configWindowCurrent(x.config) && x.api && x.isConnected());\n        let chosen: SourceWrapper[] = [];\n        let covered = 0;\n        while (covered < 1) {\n            let best: SourceWrapper | undefined;\n            let bestEnd = covered;\n            for (let source of candidates) {\n                let [start, end] = source.config.route || FULL_ROUTE;\n                if (start > covered) continue;\n                if (end > bestEnd) {\n                    bestEnd = end;\n                    best = source;\n                }\n            }\n            if (!best) {\n                throw new Error(`Cannot cover the full route space for ${this.getDebugName()}: the available sources only cover up to ${covered} (some shards are down or URL-only)`);\n            }\n            chosen.push(best);\n            covered = bestEnd;\n        }\n        return chosen;\n    }\n\n    private async runOnApi<T>(source: SourceWrapper, run: (archives: IArchives) => Promise<T>): Promise<T> {\n        let api = source.api;\n        if (!api) {\n            throw new Error(`${source.config.url} has URL-only access, which cannot serve this operation`);\n        }\n        return await run(api);\n    }\n\n    public async find(prefix: string, config?: { shallow?: boolean; type: \"files\" | \"folders\" }): Promise<string[]> {\n        return (await this.findInfo(prefix, config)).map(x => x.path);\n    }\n    public async findInfo(prefix: string, config?: { shallow?: boolean; type: \"files\" | \"folders\" }): Promise<ArchiveFileInfo[]> {\n        let state = await this.getState();\n        let covering = this.selectCoveringSources(state);\n        let results = await Promise.all(covering.map(source => this.runOnApi(source, archives => archives.findInfo(prefix, config))));\n        // Overlapping shards can both report a path; the newest wins\n        let byPath = new Map<string, ArchiveFileInfo>();\n        for (let list of results) {\n            for (let file of list) {\n                let existing = byPath.get(file.path);\n                if (!existing || file.createTime > existing.createTime) {\n                    byPath.set(file.path, file);\n                }\n            }\n        }\n        let merged = [...byPath.values()];\n        sort(merged, x => x.path);\n        return merged;\n    }\n    public async getChangesAfter(time: number): Promise<ArchiveFileInfo[]> {\n        let state = await this.getState();\n        let covering = this.selectCoveringSources(state);\n        let results = await Promise.all(covering.map(source => this.runOnApi(source, async archives => {\n            if (!archives.getChangesAfter) {\n                throw new Error(`${archives.getDebugName()} does not support getChangesAfter`);\n            }\n            return await archives.getChangesAfter(time);\n        })));\n        let byPath = new Map<string, ArchiveFileInfo>();\n        for (let list of results) {\n            for (let file of list) {\n                let existing = byPath.get(file.path);\n                if (!existing || file.createTime > existing.createTime) {\n                    byPath.set(file.path, file);\n                }\n            }\n        }\n        let merged = [...byPath.values()];\n        sort(merged, x => x.path);\n        return merged;\n    }\n    public async getSyncStatus(): Promise<ArchivesSyncStatus> {\n        let state = await this.getState();\n        let covering = this.selectCoveringSources(state);\n        let statuses = await Promise.all(covering.map(source => this.runOnApi(source, async archives => {\n            if (!archives.getSyncStatus) {\n                throw new Error(`${archives.getDebugName()} does not support getSyncStatus`);\n            }\n            return await archives.getSyncStatus();\n        })));\n        return {\n            allScansComplete: statuses.every(x => x.allScansComplete),\n            indexSize: statuses.reduce((sum, x) => sum + x.indexSize, 0),\n            sources: statuses.flatMap(x => x.sources),\n        };\n    }\n    public async getConfig(): Promise<ArchivesConfig> {\n        let state = await this.getState();\n        if (!state.sources.some(x => x.api)) return { remoteConfig: state.config };\n        let config = await this.run(state, { apiOnly: true }, archives => archives.getConfig());\n        return { ...config, remoteConfig: state.config };\n    }\n    /** True only when EVERY write-receiving source would accept our writes (partial write access\n     *  desynchronizes sources, so it counts as no access). */\n    public async hasWriteAccess(): Promise<boolean> {\n        let state = await this.getState();\n        for (let source of state.sources) {\n            if (!configAcceptsWrites(source.config)) continue;\n            if (!await source.hasWriteAccess()) return false;\n        }\n        return true;\n    }\n\n    private assertNotBareVariableShard(fileName: string): void {\n        if (fileName.includes(VARIABLE_SHARD) && parseVariableRoute(fileName) === undefined) {\n            throw new Error(`Keys containing VARIABLE_SHARD must be written with setVariableShard, which materializes the shard value and returns the full key. Key: ${JSON.stringify(fileName)}`);\n        }\n    }\n\n    public async set(fileName: string, data: Buffer, config?: { lastModified?: number }): Promise<void> {\n        this.assertNotBareVariableShard(fileName);\n        await this.request({ write: true, route: getRoute(fileName) }, archives => archives.set(fileName, data, config));\n    }\n    public async del(fileName: string): Promise<void> {\n        await this.request({ write: true, route: getRoute(fileName) }, archives => archives.del(fileName));\n    }\n\n    /** Writes a key containing the VARIABLE_SHARD sentinel: picks the lowest-latency up write\n     *  shard, materializes the key with a random value inside that shard's route, writes it, and\n     *  returns the FULL key actually written (the caller needs it to ever read the value back).\n     *  Unlike normal writes this CAN move to another shard when the preferred one is down (error +\n     *  socket down, same rule as reads) - each shard receives a different key, so write\n     *  consistency is preserved. */\n    public async setVariableShard(key: string, data: Buffer, config?: { lastModified?: number }): Promise<string> {\n        if (!key.includes(VARIABLE_SHARD)) {\n            throw new Error(`Expected the key to contain the VARIABLE_SHARD sentinel, was ${JSON.stringify(key)}`);\n        }\n        if (parseVariableRoute(key) !== undefined) {\n            throw new Error(`The key already has a materialized shard value; write it with set instead. Key: ${JSON.stringify(key)}`);\n        }\n        let state = await this.getState();\n        // Per-shard write consistency still holds: within a route, only the FIRST source may take\n        // writes - latency only picks WHICH shard the key materializes into\n        let targetsByRoute = new Map<string, SourceWrapper>();\n        for (let source of state.sources) {\n            if (!configAcceptsWrites(source.config)) continue;\n            let routeKey = JSON.stringify(source.config.route || FULL_ROUTE);\n            if (!targetsByRoute.has(routeKey)) {\n                targetsByRoute.set(routeKey, source);\n            }\n        }\n        let targets = [...targetsByRoute.values()];\n        sort(targets, x => x.getLatency());\n        let errors: string[] = [];\n        for (let target of targets) {\n            if (!target.isConnected()) {\n                target.noteFailure();\n                errors.push(`${target.config.url} is not connected`);\n                continue;\n            }\n            let [start, end] = target.config.route || FULL_ROUTE;\n            let fullKey = key.replace(VARIABLE_SHARD, VARIABLE_SHARD + \"_\" + (start + Math.random() * (end - start)));\n            try {\n                await target.write(archives => archives.set(fullKey, data, config));\n                return fullKey;\n            } catch (e) {\n                // An error alone doesn't justify moving on (it would be an application error); the\n                // socket must also be down\n                if (target.isConnected()) throw e;\n                target.noteFailure();\n                errors.push(String((e as Error).stack ?? e));\n            }\n        }\n        throw new Error(`Every variable-shard write target failed for ${this.getDebugName()}: ${errors.join(\" | \") || \"no sources accept writes\"}`);\n    }\n\n    public async setLargeFile(config: { path: string; getNextData(): Promise<Buffer | undefined> }): Promise<void> {\n        this.assertNotBareVariableShard(config.path);\n        let state = await this.getState();\n        // Same consistency rule as runWrite: the first currently-valid source for the route, or nothing\n        let route = getRoute(config.path);\n        let target = state.sources.find(x => configAcceptsWrites(x.config) && routeContains(x.config.route, route));\n        if (!target) {\n            throw new Error(`No source accepts writes for setLargeFile on ${this.getDebugName()} (route ${route})`);\n        }\n        if (!target.isConnected()) {\n            target.noteFailure();\n            throw new Error(`Cannot write: the write target ${target.config.url} is not connected (writes never fail over to other sources)`);\n        }\n        await target.write(archives => archives.setLargeFile(config));\n    }\n\n    public async getURL(path: string): Promise<string> {\n        let state = await this.getState();\n        let route = getRoute(path);\n        for (let source of state.sources) {\n            if (source.config.public === false) continue;\n            if (!routeContains(source.config.route, route)) continue;\n            if (source.url) return await source.url.getURL(path);\n            if (source.api) return await source.api.getURL(path);\n        }\n        throw new Error(`No public source covering route ${route} to build a URL from for ${this.getDebugName()}`);\n    }\n\n    public dispose(): void {\n        this.disposed = true;\n        if (this.pollTimer) {\n            clearInterval(this.pollTimer);\n        }\n        if (this.initRetryTimer) {\n            clearTimeout(this.initRetryTimer);\n        }\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\n// The IArchives for a RemoteConfig (or a single source - a routing URL string works). Fully lazy:\n// nothing is contacted until the first call. Call dispose() when done with it, so its background\n// retry/poll loops stop.\nexport function createArchives(config: RemoteConfig | RemoteConfigBase): ArchivesChain {\n    return new ArchivesChain(config);\n}\n"]}
+ /* _JS_SOURCE_HASH = "50c50395ddf2ffcc2dd4351bc8b06baf4be9bfc73f82dc2694defa4b5c96e13c"; */