sliftutils 1.7.13 → 1.7.14

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

@@ -0,0 +1,371 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule && mod.default) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.getMainPortAcquireDelay = exports.getFlushDeadline = exports.applyDeployRemap = exports.onTakeoverEvent = exports.registerAltPort = exports.initDeployTakeover = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const remoteConfig_1 = require("./remoteConfig");
+// Deploy takeover: the deploy manager (querysub's parametersTimeline) writes <n>-parameters.json
+// files into our instance folder describing when each version runs and when it is shut down. Old
+// and new version overlap for the overlap time (O = oldEnd - newStart). We turn that overlap into
+// an atomic write handoff by REINTERPRETING every routing source that points at us: its valid
+// window is split so that the middle of the overlap ([S + 0.5*O, S + 1.5*O]) points at the new
+// process's temporary alternate port. The existing valid-window machinery then does everything -
+// the old process starts rejecting fresh writes at the first boundary, clients re-resolve, and the
+// new process (which recognizes the alternate port as itself) takes over. The remap is an
+// INTERPRETATION OVERLAY, applied where routing configs are used (see applyDeployRemap callers) -
+// it is never written to disk, never synchronized, and never part of any stored configuration.
+//
+// Everything here is recomputed idempotently from its inputs (timeline files, the port registry,
+// our ancestor pids, the clock) - files can appear or change at any moment, and we can start at
+// any point during a switchover.
+const PARAMETERS_TIMELINE_FILE_REGEX = /^(\d+)-parameters\.json$/;
+const ALIVE_WINDOW_FOREVER = Number.MAX_SAFE_INTEGER;
+const TIMELINE_POLL_INTERVAL = 60 * 1000;
+// Processes listening on an alternate port register it here (sibling of the storage folder), keyed
+// by their actual pid; content includes their ancestor pids so the timeline entry pid (a shell
+// ancestor of the process) can be matched to a registry entry
+const PORT_REGISTRY_FOLDER_NAME = "storagePortRegistry";
+// Main-port acquisition attempts run this often, tightening near the predecessor's scheduled death
+const ACQUIRE_SLOW_DELAY = 30 * 1000;
+const ACQUIRE_FAST_DELAY = 5 * 1000;
+const ACQUIRE_FAST_WINDOW = 60 * 1000;
+// Disk rescans fire this far before and after the write handoff, catching files the other process
+// wrote (the BulkDatabase2 index is atomic but its entries land at write time, not file time)
+const SWITCH_SCAN_LEAD = 10 * 1000;
+// The dying process must have flushed everything before the handoff: fast-write delays never
+// extend past S + overlap * this fraction, and after that point fast writes flush immediately
+const FLUSH_DEADLINE_FRACTION = 0.25;
+const BOUNDARY_A_FRACTION = 0.5;
+const BOUNDARY_B_FRACTION = 1.5;
+const REMAP_EXPIRE_FRACTION = 2;
+let initialized;
+let ancestorPids = new Set();
+let timelineFolder;
+let ourAltPort;
+let current = {};
+let currentKey = JSON.stringify(current);
+let eventListeners = [];
+let eventTimers = [];
+function execText(command) {
+    return new Promise((resolve, reject) => {
+        (0, child_process_1.exec)(command, (error, stdout) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve(stdout);
+        });
+    });
+}
+// The timeline entry pid is the screen shell that spawned us - an ancestor - so we walk our whole
+// ancestor chain to find which entry is us
+async function getAncestorPids() {
+    let pids = new Set([process.pid]);
+    let currentPid = process.pid;
+    while (true) {
+        let ppid;
+        if (currentPid === process.pid && process.ppid) {
+            ppid = process.ppid;
+        }
+        else {
+            try {
+                ppid = parseInt((await execText(`ps -o ppid= -p ${currentPid}`)).trim());
+            }
+            catch (_a) {
+                break;
+            }
+        }
+        if (!ppid || Number.isNaN(ppid) || ppid <= 1 || pids.has(ppid))
+            break;
+        pids.add(ppid);
+        currentPid = ppid;
+    }
+    return pids;
+}
+async function findTimelineFolder() {
+    let dir = process.cwd();
+    while (true) {
+        let files = [];
+        try {
+            files = await fs_1.default.promises.readdir(dir);
+        }
+        catch (_a) { }
+        if (files.some(file => PARAMETERS_TIMELINE_FILE_REGEX.test(file))) {
+            return dir.replaceAll("\\", "/") + "/";
+        }
+        let parent = path_1.default.dirname(dir);
+        if (parent === dir)
+            return undefined;
+        dir = parent;
+    }
+}
+function pidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return e.code === "EPERM";
+    }
+}
+function getRegistryFolder() {
+    if (!initialized) {
+        throw new Error(`Deploy takeover is not initialized`);
+    }
+    return path_1.default.join(path_1.default.dirname(path_1.default.resolve(initialized.storageFolder)), PORT_REGISTRY_FOLDER_NAME);
+}
+async function readPortRegistry() {
+    let folder = getRegistryFolder();
+    let files = [];
+    try {
+        files = await fs_1.default.promises.readdir(folder);
+    }
+    catch (_a) {
+        return [];
+    }
+    let entries = [];
+    for (let file of files) {
+        let match = /^(\d+)\.json$/.exec(file);
+        if (!match)
+            continue;
+        let pid = parseInt(match[1]);
+        if (!pidAlive(pid)) {
+            try {
+                await fs_1.default.promises.unlink(path_1.default.join(folder, file));
+            }
+            catch (_b) { }
+            continue;
+        }
+        try {
+            let entry = JSON.parse(await fs_1.default.promises.readFile(path_1.default.join(folder, file), "utf8"));
+            entries.push({ ...entry, pid });
+        }
+        catch (_c) { }
+    }
+    return entries;
+}
+async function readTimelineEntries() {
+    var _a;
+    if (!timelineFolder)
+        return [];
+    let entries = [];
+    for (let file of await fs_1.default.promises.readdir(timelineFolder)) {
+        if (!PARAMETERS_TIMELINE_FILE_REGEX.test(file))
+            continue;
+        try {
+            entries.push(JSON.parse(await fs_1.default.promises.readFile(timelineFolder + file, "utf8")));
+        }
+        catch (e) {
+            console.warn(`Could not read deploy timeline file ${timelineFolder + file}: ${(_a = e.stack) !== null && _a !== void 0 ? _a : e}`);
+        }
+    }
+    return entries;
+}
+function makeRemap(successorStart, overlap, altPort) {
+    return {
+        boundaryA: successorStart + overlap * BOUNDARY_A_FRACTION,
+        boundaryB: successorStart + overlap * BOUNDARY_B_FRACTION,
+        expire: successorStart + overlap * REMAP_EXPIRE_FRACTION,
+        altPort,
+    };
+}
+function emit(event) {
+    var _a;
+    for (let listener of eventListeners) {
+        try {
+            listener(event);
+        }
+        catch (e) {
+            console.error(`Deploy takeover listener failed: ${(_a = e.stack) !== null && _a !== void 0 ? _a : e}`);
+        }
+    }
+}
+function scheduleEvents() {
+    for (let timer of eventTimers) {
+        clearTimeout(timer);
+    }
+    eventTimers = [];
+    let now = Date.now();
+    let schedule = (time, fnc) => {
+        var _a, _b;
+        if (time <= now)
+            return;
+        let timer = setTimeout(fnc, time - now);
+        (_b = (_a = timer).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
+        eventTimers.push(timer);
+    };
+    let remap = current.remap;
+    if (remap) {
+        schedule(remap.boundaryA - SWITCH_SCAN_LEAD, () => emit("diskScan"));
+        schedule(remap.boundaryA + SWITCH_SCAN_LEAD, () => emit("diskScan"));
+        schedule(remap.expire, () => void recompute().catch((e) => { var _a; return console.error(`Deploy takeover recompute failed: ${(_a = e.stack) !== null && _a !== void 0 ? _a : e}`); }));
+    }
+}
+async function recompute() {
+    if (!initialized || !timelineFolder)
+        return;
+    let now = Date.now();
+    let entries = await readTimelineEntries();
+    let registry = await readPortRegistry();
+    let us;
+    for (let entry of entries) {
+        if (entry.pid && ancestorPids.has(entry.pid)) {
+            us = entry;
+        }
+    }
+    let computed = {};
+    if (us) {
+        let usStart = us.aliveWindow[0];
+        let next;
+        let prev;
+        for (let entry of entries) {
+            if (entry === us)
+                continue;
+            if (entry.aliveWindow[0] > usStart && (!next || entry.aliveWindow[0] < next.aliveWindow[0])) {
+                next = entry;
+            }
+            if (entry.aliveWindow[0] < usStart && (!prev || entry.aliveWindow[0] > prev.aliveWindow[0])) {
+                prev = entry;
+            }
+        }
+        if (next && us.aliveWindow[1] !== ALIVE_WINDOW_FOREVER && next.aliveWindow[0] <= us.aliveWindow[1]) {
+            let overlap = us.aliveWindow[1] - next.aliveWindow[0];
+            let successorStart = next.aliveWindow[0];
+            if (overlap > 0 && now < successorStart + overlap * REMAP_EXPIRE_FRACTION) {
+                computed.dying = { successorStart, overlap };
+                const successorPid = next.pid;
+                if (successorPid) {
+                    let successorEntry = registry.find(x => x.ancestorPids.includes(successorPid));
+                    if (successorEntry) {
+                        computed.remap = makeRemap(successorStart, overlap, successorEntry.port);
+                    }
+                }
+            }
+        }
+        if (prev && prev.aliveWindow[1] > usStart) {
+            let overlap = prev.aliveWindow[1] - usStart;
+            computed.predecessorEnd = prev.aliveWindow[1];
+            if (overlap > 0 && ourAltPort && now < usStart + overlap * REMAP_EXPIRE_FRACTION && !computed.remap) {
+                computed.remap = makeRemap(usStart, overlap, ourAltPort);
+            }
+        }
+    }
+    let key = JSON.stringify(computed);
+    if (key === currentKey)
+        return;
+    current = computed;
+    currentKey = key;
+    console.log(`Deploy takeover state changed: ${key}`);
+    scheduleEvents();
+    emit("remapChanged");
+}
+/** Starts the takeover machinery. Returns whether a deploy timeline exists - when it doesn't,
+ *  everything here stays inert (and the caller must NOT fall back to alternate ports, since a busy
+ *  port then means a real misconfiguration, not a deploy). */
+async function initDeployTakeover(config) {
+    var _a, _b;
+    initialized = config;
+    ancestorPids = await getAncestorPids();
+    timelineFolder = await findTimelineFolder();
+    if (!timelineFolder)
+        return false;
+    await recompute();
+    let poll = setInterval(() => {
+        void recompute().catch((e) => { var _a; return console.error(`Deploy takeover recompute failed: ${(_a = e.stack) !== null && _a !== void 0 ? _a : e}`); });
+    }, TIMELINE_POLL_INTERVAL);
+    (_b = (_a = poll).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
+    return true;
+}
+exports.initDeployTakeover = initDeployTakeover;
+/** Called when we had to listen on an alternate port (the main port was still held by our
+ *  predecessor): registers it so the predecessor can route the middle overlap window to us. */
+async function registerAltPort(port) {
+    ourAltPort = port;
+    let folder = getRegistryFolder();
+    await fs_1.default.promises.mkdir(folder, { recursive: true });
+    let entry = { pid: process.pid, port, ancestorPids: [...ancestorPids] };
+    await fs_1.default.promises.writeFile(path_1.default.join(folder, `${process.pid}.json`), JSON.stringify(entry));
+    await recompute();
+}
+exports.registerAltPort = registerAltPort;
+function onTakeoverEvent(listener) {
+    eventListeners.push(listener);
+}
+exports.onTakeoverEvent = onTakeoverEvent;
+/** The interpretation overlay: splits every source pointing at our domain+main port so the middle
+ *  of the deploy overlap points at the alternate port. Pure, in-memory only - the stored routing
+ *  config is never modified, and this must never be applied to data that gets persisted. */
+function applyDeployRemap(routing) {
+    let remap = current.remap;
+    let init = initialized;
+    if (!remap || !init)
+        return routing;
+    let sources = [];
+    let slice = (source, start, end, url) => {
+        return { ...source, url: url || source.url, validWindow: [start, end] };
+    };
+    for (let source of routing.sources) {
+        if (typeof source === "string" || source.type !== "remote") {
+            sources.push(source);
+            continue;
+        }
+        let parsed;
+        try {
+            parsed = (0, remoteConfig_1.parseHostedUrl)(source.url);
+        }
+        catch (_a) {
+            sources.push(source);
+            continue;
+        }
+        if (parsed.address !== init.domain || parsed.port !== init.mainPort) {
+            sources.push(source);
+            continue;
+        }
+        let [start, end] = source.validWindow;
+        let a = Math.max(start, Math.min(remap.boundaryA, end));
+        let b = Math.max(start, Math.min(remap.boundaryB, end));
+        let added = false;
+        if (a > start) {
+            sources.push(slice(source, start, a));
+            added = true;
+        }
+        if (b > a) {
+            sources.push(slice(source, a, b, (0, remoteConfig_1.replaceHostedUrlPort)(source.url, remap.altPort)));
+            added = true;
+        }
+        if (end > b) {
+            sources.push(slice(source, b, end));
+            added = true;
+        }
+        if (!added) {
+            sources.push(source);
+        }
+    }
+    return { version: routing.version, sources };
+}
+exports.applyDeployRemap = applyDeployRemap;
+/** For the dying process: fast-write flush delays must never extend past this time, and after it
+ *  fast writes flush immediately - so nothing is left in memory when the write window transfers. */
+function getFlushDeadline() {
+    let dying = current.dying;
+    if (!dying)
+        return undefined;
+    return dying.successorStart + dying.overlap * FLUSH_DEADLINE_FRACTION;
+}
+exports.getFlushDeadline = getFlushDeadline;
+/** How long to wait between main-port acquisition attempts: tight around the predecessor's
+ *  scheduled death (when the port actually frees), relaxed otherwise. */
+function getMainPortAcquireDelay() {
+    let end = current.predecessorEnd;
+    if (end !== undefined && Math.abs(Date.now() - end) <= ACQUIRE_FAST_WINDOW) {
+        return ACQUIRE_FAST_DELAY;
+    }
+    return ACQUIRE_SLOW_DELAY;
+}
+exports.getMainPortAcquireDelay = getMainPortAcquireDelay;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"deployTakeover.js","sourceRoot":"","sources":["deployTakeover.ts"],"names":[],"mappings":";;;;;;AAAA,4CAAoB;AACpB,gDAAwB;AACxB,iDAAqC;AAErC,iDAAsE;AAEtE,iGAAiG;AACjG,iGAAiG;AACjG,kGAAkG;AAClG,8FAA8F;AAC9F,+FAA+F;AAC/F,iGAAiG;AACjG,mGAAmG;AACnG,0FAA0F;AAC1F,kGAAkG;AAClG,+FAA+F;AAC/F,EAAE;AACF,iGAAiG;AACjG,gGAAgG;AAChG,iCAAiC;AAEjC,MAAM,8BAA8B,GAAG,0BAA0B,CAAC;AAClE,MAAM,oBAAoB,GAAG,MAAM,CAAC,gBAAgB,CAAC;AACrD,MAAM,sBAAsB,GAAG,EAAE,GAAG,IAAI,CAAC;AACzC,mGAAmG;AACnG,+FAA+F;AAC/F,8DAA8D;AAC9D,MAAM,yBAAyB,GAAG,qBAAqB,CAAC;AACxD,mGAAmG;AACnG,MAAM,kBAAkB,GAAG,EAAE,GAAG,IAAI,CAAC;AACrC,MAAM,kBAAkB,GAAG,CAAC,GAAG,IAAI,CAAC;AACpC,MAAM,mBAAmB,GAAG,EAAE,GAAG,IAAI,CAAC;AACtC,kGAAkG;AAClG,8FAA8F;AAC9F,MAAM,gBAAgB,GAAG,EAAE,GAAG,IAAI,CAAC;AACnC,6FAA6F;AAC7F,8FAA8F;AAC9F,MAAM,uBAAuB,GAAG,IAAI,CAAC;AACrC,MAAM,mBAAmB,GAAG,GAAG,CAAC;AAChC,MAAM,mBAAmB,GAAG,GAAG,CAAC;AAChC,MAAM,qBAAqB,GAAG,CAAC,CAAC;AAqBhC,IAAI,WAAoF,CAAC;AACzF,IAAI,YAAY,GAAG,IAAI,GAAG,EAAU,CAAC;AACrC,IAAI,cAAkC,CAAC;AACvC,IAAI,UAA8B,CAAC;AACnC,IAAI,OAAO,GAAqB,EAAE,CAAC;AACnC,IAAI,UAAU,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;AACzC,IAAI,cAAc,GAAuC,EAAE,CAAC;AAC5D,IAAI,WAAW,GAAoC,EAAE,CAAC;AAEtD,SAAS,QAAQ,CAAC,OAAe;IAC7B,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QACnC,IAAA,oBAAI,EAAC,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE;YAC5B,IAAI,KAAK,EAAE,CAAC;gBACR,MAAM,CAAC,KAAK,CAAC,CAAC;gBACd,OAAO;YACX,CAAC;YACD,OAAO,CAAC,MAAM,CAAC,CAAC;QACpB,CAAC,CAAC,CAAC;IACP,CAAC,CAAC,CAAC;AACP,CAAC;AAED,kGAAkG;AAClG,2CAA2C;AAC3C,KAAK,UAAU,eAAe;IAC1B,IAAI,IAAI,GAAG,IAAI,GAAG,CAAS,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;IAC1C,IAAI,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC;IAC7B,OAAO,IAAI,EAAE,CAAC;QACV,IAAI,IAAY,CAAC;QACjB,IAAI,UAAU,KAAK,OAAO,CAAC,GAAG,IAAI,OAAO,CAAC,IAAI,EAAE,CAAC;YAC7C,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;QACxB,CAAC;aAAM,CAAC;YACJ,IAAI,CAAC;gBACD,IAAI,GAAG,QAAQ,CAAC,CAAC,MAAM,QAAQ,CAAC,kBAAkB,UAAU,EAAE,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;YAC7E,CAAC;YAAC,WAAM,CAAC;gBACL,MAAM;YACV,CAAC;QACL,CAAC;QACD,IAAI,CAAC,IAAI,IAAI,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC;YAAE,MAAM;QACtE,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACf,UAAU,GAAG,IAAI,CAAC;IACtB,CAAC;IACD,OAAO,IAAI,CAAC;AAChB,CAAC;AAED,KAAK,UAAU,kBAAkB;IAC7B,IAAI,GAAG,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC;IACxB,OAAO,IAAI,EAAE,CAAC;QACV,IAAI,KAAK,GAAa,EAAE,CAAC;QACzB,IAAI,CAAC;YACD,KAAK,GAAG,MAAM,YAAE,CAAC,QAAQ,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAC3C,CAAC;QAAC,WAAM,CAAC,CAAC,CAAC;QACX,IAAI,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,8BAA8B,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC;YAChE,OAAO,GAAG,CAAC,UAAU,CAAC,IAAI,EAAE,GAAG,CAAC,GAAG,GAAG,CAAC;QAC3C,CAAC;QACD,IAAI,MAAM,GAAG,cAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAC/B,IAAI,MAAM,KAAK,GAAG;YAAE,OAAO,SAAS,CAAC;QACrC,GAAG,GAAG,MAAM,CAAC;IACjB,CAAC;AACL,CAAC;AAED,SAAS,QAAQ,CAAC,GAAW;IACzB,IAAI,CAAC;QACD,OAAO,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;QACrB,OAAO,IAAI,CAAC;IAChB,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACT,OAAQ,CAAuB,CAAC,IAAI,KAAK,OAAO,CAAC;IACrD,CAAC;AACL,CAAC;AAED,SAAS,iBAAiB;IACtB,IAAI,CAAC,WAAW,EAAE,CAAC;QACf,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC;IAC1D,CAAC;IACD,OAAO,cAAI,CAAC,IAAI,CAAC,cAAI,CAAC,OAAO,CAAC,cAAI,CAAC,OAAO,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC,EAAE,yBAAyB,CAAC,CAAC;AACvG,CAAC;AAID,KAAK,UAAU,gBAAgB;IAC3B,IAAI,MAAM,GAAG,iBAAiB,EAAE,CAAC;IACjC,IAAI,KAAK,GAAa,EAAE,CAAC;IACzB,IAAI,CAAC;QACD,KAAK,GAAG,MAAM,YAAE,CAAC,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IAC9C,CAAC;IAAC,WAAM,CAAC;QACL,OAAO,EAAE,CAAC;IACd,CAAC;IACD,IAAI,OAAO,GAAoB,EAAE,CAAC;IAClC,KAAK,IAAI,IAAI,IAAI,KAAK,EAAE,CAAC;QACrB,IAAI,KAAK,GAAG,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACvC,IAAI,CAAC,KAAK;YAAE,SAAS;QACrB,IAAI,GAAG,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QAC7B,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YACjB,IAAI,CAAC;gBACD,MAAM,YAAE,CAAC,QAAQ,CAAC,MAAM,CAAC,cAAI,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC;YACtD,CAAC;YAAC,WAAM,CAAC,CAAC,CAAC;YACX,SAAS;QACb,CAAC;QACD,IAAI,CAAC;YACD,IAAI,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,YAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,cAAI,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,CAAkB,CAAC;YACrG,OAAO,CAAC,IAAI,CAAC,EAAE,GAAG,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC;QACpC,CAAC;QAAC,WAAM,CAAC,CAAC,CAAC;IACf,CAAC;IACD,OAAO,OAAO,CAAC;AACnB,CAAC;AAED,KAAK,UAAU,mBAAmB;;IAC9B,IAAI,CAAC,cAAc;QAAE,OAAO,EAAE,CAAC;IAC/B,IAAI,OAAO,GAAoB,EAAE,CAAC;IAClC,KAAK,IAAI,IAAI,IAAI,MAAM,YAAE,CAAC,QAAQ,CAAC,OAAO,CAAC,cAAc,CAAC,EAAE,CAAC;QACzD,IAAI,CAAC,8BAA8B,CAAC,IAAI,CAAC,IAAI,CAAC;YAAE,SAAS;QACzD,IAAI,CAAC;YACD,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,YAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,cAAc,GAAG,IAAI,EAAE,MAAM,CAAC,CAAkB,CAAC,CAAC;QACzG,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACT,OAAO,CAAC,IAAI,CAAC,uCAAuC,cAAc,GAAG,IAAI,KAAK,MAAC,CAAW,CAAC,KAAK,mCAAI,CAAC,EAAE,CAAC,CAAC;QAC7G,CAAC;IACL,CAAC;IACD,OAAO,OAAO,CAAC;AACnB,CAAC;AAED,SAAS,SAAS,CAAC,cAAsB,EAAE,OAAe,EAAE,OAAe;IACvE,OAAO;QACH,SAAS,EAAE,cAAc,GAAG,OAAO,GAAG,mBAAmB;QACzD,SAAS,EAAE,cAAc,GAAG,OAAO,GAAG,mBAAmB;QACzD,MAAM,EAAE,cAAc,GAAG,OAAO,GAAG,qBAAqB;QACxD,OAAO;KACV,CAAC;AACN,CAAC;AAED,SAAS,IAAI,CAAC,KAAoB;;IAC9B,KAAK,IAAI,QAAQ,IAAI,cAAc,EAAE,CAAC;QAClC,IAAI,CAAC;YACD,QAAQ,CAAC,KAAK,CAAC,CAAC;QACpB,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACT,OAAO,CAAC,KAAK,CAAC,oCAAoC,MAAC,CAAW,CAAC,KAAK,mCAAI,CAAC,EAAE,CAAC,CAAC;QACjF,CAAC;IACL,CAAC;AACL,CAAC;AAED,SAAS,cAAc;IACnB,KAAK,IAAI,KAAK,IAAI,WAAW,EAAE,CAAC;QAC5B,YAAY,CAAC,KAAK,CAAC,CAAC;IACxB,CAAC;IACD,WAAW,GAAG,EAAE,CAAC;IACjB,IAAI,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IACrB,IAAI,QAAQ,GAAG,CAAC,IAAY,EAAE,GAAe,EAAE,EAAE;;QAC7C,IAAI,IAAI,IAAI,GAAG;YAAE,OAAO;QACxB,IAAI,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE,IAAI,GAAG,GAAG,CAAC,CAAC;QACxC,MAAA,MAAC,KAAgC,EAAC,KAAK,kDAAI,CAAC;QAC5C,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC5B,CAAC,CAAC;IACF,IAAI,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC;IAC1B,IAAI,KAAK,EAAE,CAAC;QACR,QAAQ,CAAC,KAAK,CAAC,SAAS,GAAG,gBAAgB,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC;QACrE,QAAQ,CAAC,KAAK,CAAC,SAAS,GAAG,gBAAgB,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC;QACrE,QAAQ,CAAC,KAAK,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,KAAK,SAAS,EAAE,CAAC,KAAK,CAAC,CAAC,CAAQ,EAAE,EAAE,WAAC,OAAA,OAAO,CAAC,KAAK,CAAC,qCAAqC,MAAA,CAAC,CAAC,KAAK,mCAAI,CAAC,EAAE,CAAC,CAAA,EAAA,CAAC,CAAC,CAAC;IAC3I,CAAC;AACL,CAAC;AAED,KAAK,UAAU,SAAS;IACpB,IAAI,CAAC,WAAW,IAAI,CAAC,cAAc;QAAE,OAAO;IAC5C,IAAI,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IACrB,IAAI,OAAO,GAAG,MAAM,mBAAmB,EAAE,CAAC;IAC1C,IAAI,QAAQ,GAAG,MAAM,gBAAgB,EAAE,CAAC;IACxC,IAAI,EAA6B,CAAC;IAClC,KAAK,IAAI,KAAK,IAAI,OAAO,EAAE,CAAC;QACxB,IAAI,KAAK,CAAC,GAAG,IAAI,YAAY,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;YAC3C,EAAE,GAAG,KAAK,CAAC;QACf,CAAC;IACL,CAAC;IACD,IAAI,QAAQ,GAAqB,EAAE,CAAC;IACpC,IAAI,EAAE,EAAE,CAAC;QACL,IAAI,OAAO,GAAG,EAAE,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;QAChC,IAAI,IAA+B,CAAC;QACpC,IAAI,IAA+B,CAAC;QACpC,KAAK,IAAI,KAAK,IAAI,OAAO,EAAE,CAAC;YACxB,IAAI,KAAK,KAAK,EAAE;gBAAE,SAAS;YAC3B,IAAI,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,GAAG,OAAO,IAAI,CAAC,CAAC,IAAI,IAAI,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;gBAC1F,IAAI,GAAG,KAAK,CAAC;YACjB,CAAC;YACD,IAAI,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,GAAG,OAAO,IAAI,CAAC,CAAC,IAAI,IAAI,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;gBAC1F,IAAI,GAAG,KAAK,CAAC;YACjB,CAAC;QACL,CAAC;QACD,IAAI,IAAI,IAAI,EAAE,CAAC,WAAW,CAAC,CAAC,CAAC,KAAK,oBAAoB,IAAI,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,CAAC;YACjG,IAAI,OAAO,GAAG,EAAE,CAAC,WAAW,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;YACtD,IAAI,cAAc,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;YACzC,IAAI,OAAO,GAAG,CAAC,IAAI,GAAG,GAAG,cAAc,GAAG,OAAO,GAAG,qBAAqB,EAAE,CAAC;gBACxE,QAAQ,CAAC,KAAK,GAAG,EAAE,cAAc,EAAE,OAAO,EAAE,CAAC;gBAC7C,MAAM,YAAY,GAAG,IAAI,CAAC,GAAG,CAAC;gBAC9B,IAAI,YAAY,EAAE,CAAC;oBACf,IAAI,cAAc,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,YAAY,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC,CAAC;oBAC/E,IAAI,cAAc,EAAE,CAAC;wBACjB,QAAQ,CAAC,KAAK,GAAG,SAAS,CAAC,cAAc,EAAE,OAAO,EAAE,cAAc,CAAC,IAAI,CAAC,CAAC;oBAC7E,CAAC;gBACL,CAAC;YACL,CAAC;QACL,CAAC;QACD,IAAI,IAAI,IAAI,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC;YACxC,IAAI,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC;YAC5C,QAAQ,CAAC,cAAc,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;YAC9C,IAAI,OAAO,GAAG,CAAC,IAAI,UAAU,IAAI,GAAG,GAAG,OAAO,GAAG,OAAO,GAAG,qBAAqB,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAC;gBAClG,QAAQ,CAAC,KAAK,GAAG,SAAS,CAAC,OAAO,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;YAC7D,CAAC;QACL,CAAC;IACL,CAAC;IACD,IAAI,GAAG,GAAG,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC;IACnC,IAAI,GAAG,KAAK,UAAU;QAAE,OAAO;IAC/B,OAAO,GAAG,QAAQ,CAAC;IACnB,UAAU,GAAG,GAAG,CAAC;IACjB,OAAO,CAAC,GAAG,CAAC,kCAAkC,GAAG,EAAE,CAAC,CAAC;IACrD,cAAc,EAAE,CAAC;IACjB,IAAI,CAAC,cAAc,CAAC,CAAC;AACzB,CAAC;AAED;;8DAE8D;AACvD,KAAK,UAAU,kBAAkB,CAAC,MAAmE;;IACxG,WAAW,GAAG,MAAM,CAAC;IACrB,YAAY,GAAG,MAAM,eAAe,EAAE,CAAC;IACvC,cAAc,GAAG,MAAM,kBAAkB,EAAE,CAAC;IAC5C,IAAI,CAAC,cAAc;QAAE,OAAO,KAAK,CAAC;IAClC,MAAM,SAAS,EAAE,CAAC;IAClB,IAAI,IAAI,GAAG,WAAW,CAAC,GAAG,EAAE;QACxB,KAAK,SAAS,EAAE,CAAC,KAAK,CAAC,CAAC,CAAQ,EAAE,EAAE,WAAC,OAAA,OAAO,CAAC,KAAK,CAAC,qCAAqC,MAAA,CAAC,CAAC,KAAK,mCAAI,CAAC,EAAE,CAAC,CAAA,EAAA,CAAC,CAAC;IAC7G,CAAC,EAAE,sBAAsB,CAAC,CAAC;IAC3B,MAAA,MAAC,IAA+B,EAAC,KAAK,kDAAI,CAAC;IAC3C,OAAO,IAAI,CAAC;AAChB,CAAC;AAXD,gDAWC;AAED;+FAC+F;AACxF,KAAK,UAAU,eAAe,CAAC,IAAY;IAC9C,UAAU,GAAG,IAAI,CAAC;IAClB,IAAI,MAAM,GAAG,iBAAiB,EAAE,CAAC;IACjC,MAAM,YAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,MAAM,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;IACrD,IAAI,KAAK,GAAkB,EAAE,GAAG,EAAE,OAAO,CAAC,GAAG,EAAE,IAAI,EAAE,YAAY,EAAE,CAAC,GAAG,YAAY,CAAC,EAAE,CAAC;IACvF,MAAM,YAAE,CAAC,QAAQ,CAAC,SAAS,CAAC,cAAI,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,OAAO,CAAC,GAAG,OAAO,CAAC,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC;IAC7F,MAAM,SAAS,EAAE,CAAC;AACtB,CAAC;AAPD,0CAOC;AAED,SAAgB,eAAe,CAAC,QAAwC;IACpE,cAAc,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;AAClC,CAAC;AAFD,0CAEC;AAED;;4FAE4F;AAC5F,SAAgB,gBAAgB,CAAC,OAAqB;IAClD,IAAI,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC;IAC1B,IAAI,IAAI,GAAG,WAAW,CAAC;IACvB,IAAI,CAAC,KAAK,IAAI,CAAC,IAAI;QAAE,OAAO,OAAO,CAAC;IACpC,IAAI,OAAO,GAAuB,EAAE,CAAC;IACrC,IAAI,KAAK,GAAG,CAAC,MAAoB,EAAE,KAAa,EAAE,GAAW,EAAE,GAAY,EAAgB,EAAE;QACzF,OAAO,EAAE,GAAG,MAAM,EAAE,GAAG,EAAE,GAAG,IAAI,MAAM,CAAC,GAAG,EAAE,WAAW,EAAE,CAAC,KAAK,EAAE,GAAG,CAAC,EAAE,CAAC;IAC5E,CAAC,CAAC;IACF,KAAK,IAAI,MAAM,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;QACjC,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;YACzD,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YACrB,SAAS;QACb,CAAC;QACD,IAAI,MAAyC,CAAC;QAC9C,IAAI,CAAC;YACD,MAAM,GAAG,IAAA,6BAAc,EAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QACxC,CAAC;QAAC,WAAM,CAAC;YACL,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YACrB,SAAS;QACb,CAAC;QACD,IAAI,MAAM,CAAC,OAAO,KAAK,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,IAAI,KAAK,IAAI,CAAC,QAAQ,EAAE,CAAC;YAClE,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YACrB,SAAS;QACb,CAAC;QACD,IAAI,CAAC,KAAK,EAAE,GAAG,CAAC,GAAG,MAAM,CAAC,WAAW,CAAC;QACtC,IAAI,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC,CAAC;QACxD,IAAI,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC,CAAC;QACxD,IAAI,KAAK,GAAG,KAAK,CAAC;QAClB,IAAI,CAAC,GAAG,KAAK,EAAE,CAAC;YACZ,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC;YACtC,KAAK,GAAG,IAAI,CAAC;QACjB,CAAC;QACD,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;YACR,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC,EAAE,IAAA,mCAAoB,EAAC,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;YACnF,KAAK,GAAG,IAAI,CAAC;QACjB,CAAC;QACD,IAAI,GAAG,GAAG,CAAC,EAAE,CAAC;YACV,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC;YACpC,KAAK,GAAG,IAAI,CAAC;QACjB,CAAC;QACD,IAAI,CAAC,KAAK,EAAE,CAAC;YACT,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACzB,CAAC;IACL,CAAC;IACD,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,CAAC;AACjD,CAAC;AA7CD,4CA6CC;AAED;oGACoG;AACpG,SAAgB,gBAAgB;IAC5B,IAAI,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC;IAC1B,IAAI,CAAC,KAAK;QAAE,OAAO,SAAS,CAAC;IAC7B,OAAO,KAAK,CAAC,cAAc,GAAG,KAAK,CAAC,OAAO,GAAG,uBAAuB,CAAC;AAC1E,CAAC;AAJD,4CAIC;AAED;yEACyE;AACzE,SAAgB,uBAAuB;IACnC,IAAI,GAAG,GAAG,OAAO,CAAC,cAAc,CAAC;IACjC,IAAI,GAAG,KAAK,SAAS,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,GAAG,CAAC,IAAI,mBAAmB,EAAE,CAAC;QACzE,OAAO,kBAAkB,CAAC;IAC9B,CAAC;IACD,OAAO,kBAAkB,CAAC;AAC9B,CAAC;AAND,0DAMC","sourcesContent":["import fs from \"fs\";\nimport path from \"path\";\nimport { exec } from \"child_process\";\nimport { RemoteConfig, RemoteConfigBase, HostedConfig } from \"../IArchives\";\nimport { parseHostedUrl, replaceHostedUrlPort } from \"./remoteConfig\";\n\n// Deploy takeover: the deploy manager (querysub's parametersTimeline) writes <n>-parameters.json\n// files into our instance folder describing when each version runs and when it is shut down. Old\n// and new version overlap for the overlap time (O = oldEnd - newStart). We turn that overlap into\n// an atomic write handoff by REINTERPRETING every routing source that points at us: its valid\n// window is split so that the middle of the overlap ([S + 0.5*O, S + 1.5*O]) points at the new\n// process's temporary alternate port. The existing valid-window machinery then does everything -\n// the old process starts rejecting fresh writes at the first boundary, clients re-resolve, and the\n// new process (which recognizes the alternate port as itself) takes over. The remap is an\n// INTERPRETATION OVERLAY, applied where routing configs are used (see applyDeployRemap callers) -\n// it is never written to disk, never synchronized, and never part of any stored configuration.\n//\n// Everything here is recomputed idempotently from its inputs (timeline files, the port registry,\n// our ancestor pids, the clock) - files can appear or change at any moment, and we can start at\n// any point during a switchover.\n\nconst PARAMETERS_TIMELINE_FILE_REGEX = /^(\\d+)-parameters\\.json$/;\nconst ALIVE_WINDOW_FOREVER = Number.MAX_SAFE_INTEGER;\nconst TIMELINE_POLL_INTERVAL = 60 * 1000;\n// Processes listening on an alternate port register it here (sibling of the storage folder), keyed\n// by their actual pid; content includes their ancestor pids so the timeline entry pid (a shell\n// ancestor of the process) can be matched to a registry entry\nconst PORT_REGISTRY_FOLDER_NAME = \"storagePortRegistry\";\n// Main-port acquisition attempts run this often, tightening near the predecessor's scheduled death\nconst ACQUIRE_SLOW_DELAY = 30 * 1000;\nconst ACQUIRE_FAST_DELAY = 5 * 1000;\nconst ACQUIRE_FAST_WINDOW = 60 * 1000;\n// Disk rescans fire this far before and after the write handoff, catching files the other process\n// wrote (the BulkDatabase2 index is atomic but its entries land at write time, not file time)\nconst SWITCH_SCAN_LEAD = 10 * 1000;\n// The dying process must have flushed everything before the handoff: fast-write delays never\n// extend past S + overlap * this fraction, and after that point fast writes flush immediately\nconst FLUSH_DEADLINE_FRACTION = 0.25;\nconst BOUNDARY_A_FRACTION = 0.5;\nconst BOUNDARY_B_FRACTION = 1.5;\nconst REMAP_EXPIRE_FRACTION = 2;\n\ntype TimelineEntry = {\n    pid?: number;\n    aliveWindow: [number, number];\n    parameters: unknown;\n};\n\ntype TakeoverComputed = {\n    // We are scheduled to die with a successor overlapping us (known from the files alone, before\n    // the successor's port is discovered - the flush deadline applies immediately)\n    dying?: { successorStart: number; overlap: number };\n    // The window reinterpretation, once the middle window's port is known (the successor's\n    // registered alternate port - or our own, when we ARE the successor)\n    remap?: { boundaryA: number; boundaryB: number; expire: number; altPort: number };\n    // When our predecessor dies and frees the main port (for acquisition pacing)\n    predecessorEnd?: number;\n};\n\nexport type TakeoverEvent = \"remapChanged\" | \"diskScan\";\n\nlet initialized: { domain: string; mainPort: number; storageFolder: string } | undefined;\nlet ancestorPids = new Set<number>();\nlet timelineFolder: string | undefined;\nlet ourAltPort: number | undefined;\nlet current: TakeoverComputed = {};\nlet currentKey = JSON.stringify(current);\nlet eventListeners: ((event: TakeoverEvent) => void)[] = [];\nlet eventTimers: ReturnType<typeof setTimeout>[] = [];\n\nfunction execText(command: string): Promise<string> {\n    return new Promise((resolve, reject) => {\n        exec(command, (error, stdout) => {\n            if (error) {\n                reject(error);\n                return;\n            }\n            resolve(stdout);\n        });\n    });\n}\n\n// The timeline entry pid is the screen shell that spawned us - an ancestor - so we walk our whole\n// ancestor chain to find which entry is us\nasync function getAncestorPids(): Promise<Set<number>> {\n    let pids = new Set<number>([process.pid]);\n    let currentPid = process.pid;\n    while (true) {\n        let ppid: number;\n        if (currentPid === process.pid && process.ppid) {\n            ppid = process.ppid;\n        } else {\n            try {\n                ppid = parseInt((await execText(`ps -o ppid= -p ${currentPid}`)).trim());\n            } catch {\n                break;\n            }\n        }\n        if (!ppid || Number.isNaN(ppid) || ppid <= 1 || pids.has(ppid)) break;\n        pids.add(ppid);\n        currentPid = ppid;\n    }\n    return pids;\n}\n\nasync function findTimelineFolder(): Promise<string | undefined> {\n    let dir = process.cwd();\n    while (true) {\n        let files: string[] = [];\n        try {\n            files = await fs.promises.readdir(dir);\n        } catch { }\n        if (files.some(file => PARAMETERS_TIMELINE_FILE_REGEX.test(file))) {\n            return dir.replaceAll(\"\\\\\", \"/\") + \"/\";\n        }\n        let parent = path.dirname(dir);\n        if (parent === dir) return undefined;\n        dir = parent;\n    }\n}\n\nfunction pidAlive(pid: number): boolean {\n    try {\n        process.kill(pid, 0);\n        return true;\n    } catch (e) {\n        return (e as { code?: string }).code === \"EPERM\";\n    }\n}\n\nfunction getRegistryFolder(): string {\n    if (!initialized) {\n        throw new Error(`Deploy takeover is not initialized`);\n    }\n    return path.join(path.dirname(path.resolve(initialized.storageFolder)), PORT_REGISTRY_FOLDER_NAME);\n}\n\ntype RegistryEntry = { pid: number; port: number; ancestorPids: number[] };\n\nasync function readPortRegistry(): Promise<RegistryEntry[]> {\n    let folder = getRegistryFolder();\n    let files: string[] = [];\n    try {\n        files = await fs.promises.readdir(folder);\n    } catch {\n        return [];\n    }\n    let entries: RegistryEntry[] = [];\n    for (let file of files) {\n        let match = /^(\\d+)\\.json$/.exec(file);\n        if (!match) continue;\n        let pid = parseInt(match[1]);\n        if (!pidAlive(pid)) {\n            try {\n                await fs.promises.unlink(path.join(folder, file));\n            } catch { }\n            continue;\n        }\n        try {\n            let entry = JSON.parse(await fs.promises.readFile(path.join(folder, file), \"utf8\")) as RegistryEntry;\n            entries.push({ ...entry, pid });\n        } catch { }\n    }\n    return entries;\n}\n\nasync function readTimelineEntries(): Promise<TimelineEntry[]> {\n    if (!timelineFolder) return [];\n    let entries: TimelineEntry[] = [];\n    for (let file of await fs.promises.readdir(timelineFolder)) {\n        if (!PARAMETERS_TIMELINE_FILE_REGEX.test(file)) continue;\n        try {\n            entries.push(JSON.parse(await fs.promises.readFile(timelineFolder + file, \"utf8\")) as TimelineEntry);\n        } catch (e) {\n            console.warn(`Could not read deploy timeline file ${timelineFolder + file}: ${(e as Error).stack ?? e}`);\n        }\n    }\n    return entries;\n}\n\nfunction makeRemap(successorStart: number, overlap: number, altPort: number): TakeoverComputed[\"remap\"] {\n    return {\n        boundaryA: successorStart + overlap * BOUNDARY_A_FRACTION,\n        boundaryB: successorStart + overlap * BOUNDARY_B_FRACTION,\n        expire: successorStart + overlap * REMAP_EXPIRE_FRACTION,\n        altPort,\n    };\n}\n\nfunction emit(event: TakeoverEvent): void {\n    for (let listener of eventListeners) {\n        try {\n            listener(event);\n        } catch (e) {\n            console.error(`Deploy takeover listener failed: ${(e as Error).stack ?? e}`);\n        }\n    }\n}\n\nfunction scheduleEvents(): void {\n    for (let timer of eventTimers) {\n        clearTimeout(timer);\n    }\n    eventTimers = [];\n    let now = Date.now();\n    let schedule = (time: number, fnc: () => void) => {\n        if (time <= now) return;\n        let timer = setTimeout(fnc, time - now);\n        (timer as { unref?: () => void }).unref?.();\n        eventTimers.push(timer);\n    };\n    let remap = current.remap;\n    if (remap) {\n        schedule(remap.boundaryA - SWITCH_SCAN_LEAD, () => emit(\"diskScan\"));\n        schedule(remap.boundaryA + SWITCH_SCAN_LEAD, () => emit(\"diskScan\"));\n        schedule(remap.expire, () => void recompute().catch((e: Error) => console.error(`Deploy takeover recompute failed: ${e.stack ?? e}`)));\n    }\n}\n\nasync function recompute(): Promise<void> {\n    if (!initialized || !timelineFolder) return;\n    let now = Date.now();\n    let entries = await readTimelineEntries();\n    let registry = await readPortRegistry();\n    let us: TimelineEntry | undefined;\n    for (let entry of entries) {\n        if (entry.pid && ancestorPids.has(entry.pid)) {\n            us = entry;\n        }\n    }\n    let computed: TakeoverComputed = {};\n    if (us) {\n        let usStart = us.aliveWindow[0];\n        let next: TimelineEntry | undefined;\n        let prev: TimelineEntry | undefined;\n        for (let entry of entries) {\n            if (entry === us) continue;\n            if (entry.aliveWindow[0] > usStart && (!next || entry.aliveWindow[0] < next.aliveWindow[0])) {\n                next = entry;\n            }\n            if (entry.aliveWindow[0] < usStart && (!prev || entry.aliveWindow[0] > prev.aliveWindow[0])) {\n                prev = entry;\n            }\n        }\n        if (next && us.aliveWindow[1] !== ALIVE_WINDOW_FOREVER && next.aliveWindow[0] <= us.aliveWindow[1]) {\n            let overlap = us.aliveWindow[1] - next.aliveWindow[0];\n            let successorStart = next.aliveWindow[0];\n            if (overlap > 0 && now < successorStart + overlap * REMAP_EXPIRE_FRACTION) {\n                computed.dying = { successorStart, overlap };\n                const successorPid = next.pid;\n                if (successorPid) {\n                    let successorEntry = registry.find(x => x.ancestorPids.includes(successorPid));\n                    if (successorEntry) {\n                        computed.remap = makeRemap(successorStart, overlap, successorEntry.port);\n                    }\n                }\n            }\n        }\n        if (prev && prev.aliveWindow[1] > usStart) {\n            let overlap = prev.aliveWindow[1] - usStart;\n            computed.predecessorEnd = prev.aliveWindow[1];\n            if (overlap > 0 && ourAltPort && now < usStart + overlap * REMAP_EXPIRE_FRACTION && !computed.remap) {\n                computed.remap = makeRemap(usStart, overlap, ourAltPort);\n            }\n        }\n    }\n    let key = JSON.stringify(computed);\n    if (key === currentKey) return;\n    current = computed;\n    currentKey = key;\n    console.log(`Deploy takeover state changed: ${key}`);\n    scheduleEvents();\n    emit(\"remapChanged\");\n}\n\n/** Starts the takeover machinery. Returns whether a deploy timeline exists - when it doesn't,\n *  everything here stays inert (and the caller must NOT fall back to alternate ports, since a busy\n *  port then means a real misconfiguration, not a deploy). */\nexport async function initDeployTakeover(config: { domain: string; mainPort: number; storageFolder: string }): Promise<boolean> {\n    initialized = config;\n    ancestorPids = await getAncestorPids();\n    timelineFolder = await findTimelineFolder();\n    if (!timelineFolder) return false;\n    await recompute();\n    let poll = setInterval(() => {\n        void recompute().catch((e: Error) => console.error(`Deploy takeover recompute failed: ${e.stack ?? e}`));\n    }, TIMELINE_POLL_INTERVAL);\n    (poll as { unref?: () => void }).unref?.();\n    return true;\n}\n\n/** Called when we had to listen on an alternate port (the main port was still held by our\n *  predecessor): registers it so the predecessor can route the middle overlap window to us. */\nexport async function registerAltPort(port: number): Promise<void> {\n    ourAltPort = port;\n    let folder = getRegistryFolder();\n    await fs.promises.mkdir(folder, { recursive: true });\n    let entry: RegistryEntry = { pid: process.pid, port, ancestorPids: [...ancestorPids] };\n    await fs.promises.writeFile(path.join(folder, `${process.pid}.json`), JSON.stringify(entry));\n    await recompute();\n}\n\nexport function onTakeoverEvent(listener: (event: TakeoverEvent) => void): void {\n    eventListeners.push(listener);\n}\n\n/** The interpretation overlay: splits every source pointing at our domain+main port so the middle\n *  of the deploy overlap points at the alternate port. Pure, in-memory only - the stored routing\n *  config is never modified, and this must never be applied to data that gets persisted. */\nexport function applyDeployRemap(routing: RemoteConfig): RemoteConfig {\n    let remap = current.remap;\n    let init = initialized;\n    if (!remap || !init) return routing;\n    let sources: RemoteConfigBase[] = [];\n    let slice = (source: HostedConfig, start: number, end: number, url?: string): HostedConfig => {\n        return { ...source, url: url || source.url, validWindow: [start, end] };\n    };\n    for (let source of routing.sources) {\n        if (typeof source === \"string\" || source.type !== \"remote\") {\n            sources.push(source);\n            continue;\n        }\n        let parsed: { address: string; port: number };\n        try {\n            parsed = parseHostedUrl(source.url);\n        } catch {\n            sources.push(source);\n            continue;\n        }\n        if (parsed.address !== init.domain || parsed.port !== init.mainPort) {\n            sources.push(source);\n            continue;\n        }\n        let [start, end] = source.validWindow;\n        let a = Math.max(start, Math.min(remap.boundaryA, end));\n        let b = Math.max(start, Math.min(remap.boundaryB, end));\n        let added = false;\n        if (a > start) {\n            sources.push(slice(source, start, a));\n            added = true;\n        }\n        if (b > a) {\n            sources.push(slice(source, a, b, replaceHostedUrlPort(source.url, remap.altPort)));\n            added = true;\n        }\n        if (end > b) {\n            sources.push(slice(source, b, end));\n            added = true;\n        }\n        if (!added) {\n            sources.push(source);\n        }\n    }\n    return { version: routing.version, sources };\n}\n\n/** For the dying process: fast-write flush delays must never extend past this time, and after it\n *  fast writes flush immediately - so nothing is left in memory when the write window transfers. */\nexport function getFlushDeadline(): number | undefined {\n    let dying = current.dying;\n    if (!dying) return undefined;\n    return dying.successorStart + dying.overlap * FLUSH_DEADLINE_FRACTION;\n}\n\n/** How long to wait between main-port acquisition attempts: tight around the predecessor's\n *  scheduled death (when the port actually frees), relaxed otherwise. */\nexport function getMainPortAcquireDelay(): number {\n    let end = current.predecessorEnd;\n    if (end !== undefined && Math.abs(Date.now() - end) <= ACQUIRE_FAST_WINDOW) {\n        return ACQUIRE_FAST_DELAY;\n    }\n    return ACQUIRE_SLOW_DELAY;\n}\n"]}
+ /* _JS_SOURCE_HASH = "154a9252e403e54777d49b60b4db16fad1a05679ee037ae5a6db6ba73d410da3"; */

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
-//exports.serializeRemoteConfig = exports.parseRoutingData = exports.normalizeRemoteConfig = exports.normalizeSource = exports.parseBackblazeUrl = exports.parseHostedUrl = exports.buildFileUrl = exports.getBucketBaseUrl = exports.getConfigVersion = exports.routeIntersection = exports.routesOverlap = exports.routeContains = exports.getRoute = exports.parseVariableRoute = exports.ROUTING_FILE = void 0;
+//exports.serializeRemoteConfig = exports.parseRoutingData = exports.normalizeRemoteConfig = exports.normalizeSource = exports.replaceHostedUrlPort = exports.parseBackblazeUrl = exports.parseHostedUrl = exports.buildFileUrl = exports.getBucketBaseUrl = exports.getConfigVersion = exports.routeIntersection = exports.routesOverlap = exports.routeContains = exports.getRoute = exports.parseVariableRoute = exports.ROUTING_FILE = void 0;
 module.allowclient = true;
 const misc_1 = require("socket-function/src/misc");
 const bits_1 = require("socket-function/src/bits");
@@ -99,6 +99,12 @@ function parseBackblazeUrl(url) {
     return { bucketName: decodeURIComponent(parts[1]) };
 }
 exports.parseBackblazeUrl = parseBackblazeUrl;
+function replaceHostedUrlPort(url, port) {
+    let u = new URL(url);
+    u.port = String(port);
+    return u.toString();
+}
+exports.replaceHostedUrlPort = replaceHostedUrlPort;
 function normalizeSource(source) {
     if (typeof source !== "string") {
         let window = source.validWindow;
@@ -202,5 +208,5 @@ function serializeRemoteConfig(config) {
     return Buffer.from(JSON.stringify(config, undefined, 4));
 }
 exports.serializeRemoteConfig = serializeRemoteConfig;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"remoteConfig.js","sourceRoot":"","sources":["remoteConfig.ts"],"names":[],"mappings":";;;AAAA,MAAM,CAAC,WAAW,GAAG,IAAI,CAAC;AAE1B,mDAAkE;AAClE,mDAAwD;AACxD,4CAA4I;AAE5I,0FAA0F;AAC1F,+FAA+F;AAC/F,6FAA6F;AAC7F,sBAAsB;AAET,QAAA,YAAY,GAAG,6BAA6B,CAAC;AAC1D,MAAM,cAAc,GAAG,GAAG,GAAG,oBAAY,CAAC;AAE1C,MAAM,eAAe,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;AAE3C,oLAAoL;AACpL,SAAgB,kBAAkB,CAAC,GAAW;IAC1C,IAAI,KAAK,GAAG,GAAG,CAAC,OAAO,CAAC,0BAAc,CAAC,CAAC;IACxC,IAAI,KAAK,KAAK,CAAC,CAAC;QAAE,OAAO,SAAS,CAAC;IACnC,IAAI,KAAK,GAAG,mBAAmB,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,GAAG,0BAAc,CAAC,MAAM,CAAC,CAAC,CAAC;IAC/E,IAAI,CAAC,KAAK;QAAE,OAAO,SAAS,CAAC;IAC7B,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AACrB,CAAC;AAND,gDAMC;AAED,wGAAwG;AACxG,SAAgB,QAAQ,CAAC,GAAW;IAChC,IAAI,QAAQ,GAAG,kBAAkB,CAAC,GAAG,CAAC,CAAC;IACvC,IAAI,QAAQ,KAAK,SAAS;QAAE,OAAO,QAAQ,CAAC;IAC5C,IAAI,IAAI,GAAG,IAAA,mBAAY,EAAC,IAAA,uBAAgB,EAAC,GAAG,CAAC,CAAC,CAAC;IAC/C,OAAO,IAAI,GAAG,eAAe,GAAG,eAAe,CAAC;AACpD,CAAC;AALD,4BAKC;AAED,iEAAiE;AACjE,SAAgB,aAAa,CAAC,KAAmC,EAAE,KAAa;IAC5E,IAAI,CAAC,KAAK;QAAE,OAAO,IAAI,CAAC;IACxB,OAAO,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,IAAI,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;AACjD,CAAC;AAHD,sCAGC;AACD,SAAgB,aAAa,CAAC,CAA+B,EAAE,CAA+B;IAC1F,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,GAAG,CAAC,IAAI,sBAAU,CAAC;IACrC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,GAAG,CAAC,IAAI,sBAAU,CAAC;IACrC,OAAO,MAAM,GAAG,IAAI,IAAI,MAAM,GAAG,IAAI,CAAC;AAC1C,CAAC;AAJD,sCAIC;AACD,6EAA6E;AAC7E,SAAgB,iBAAiB,CAAC,CAA+B,EAAE,CAA+B;IAC9F,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,GAAG,CAAC,IAAI,sBAAU,CAAC;IACrC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,GAAG,CAAC,IAAI,sBAAU,CAAC;IACrC,IAAI,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,IAAI,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IAC/B,IAAI,KAAK,IAAI,GAAG;QAAE,OAAO,SAAS,CAAC;IACnC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC;AACxB,CAAC;AAPD,8CAOC;AAED,8FAA8F;AAC9F,SAAgB,gBAAgB,CAAC,MAAoB;;IACjD,OAAO,MAAA,MAAM,CAAC,OAAO,mCAAI,CAAC,CAAC,CAAC;AAChC,CAAC;AAFD,4CAEC;AAED,sGAAsG;AACtG,SAAgB,gBAAgB,CAAC,GAAW;IACxC,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,cAAc,CAAC,EAAE,CAAC;QAChC,MAAM,IAAI,KAAK,CAAC,6CAA6C,IAAI,CAAC,SAAS,CAAC,cAAc,CAAC,SAAS,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAC/H,CAAC;IACD,OAAO,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC;AAChD,CAAC;AALD,4CAKC;AAED,SAAgB,YAAY,CAAC,OAAe,EAAE,QAAgB;IAC1D,OAAO,OAAO,GAAG,GAAG,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AACjF,CAAC;AAFD,oCAEC;AAED,yGAAyG;AACzG,SAAgB,cAAc,CAAC,GAAW;IACtC,IAAI,IAAI,GAAG,gBAAgB,CAAC,GAAG,CAAC,CAAC;IACjC,IAAI,CAAC,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,CAAC;IACtB,IAAI,CAAC,CAAC,QAAQ,KAAK,QAAQ,EAAE,CAAC;QAC1B,MAAM,IAAI,KAAK,CAAC,mCAAmC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,QAAQ,CAAC,OAAO,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAC/G,CAAC;IACD,IAAI,KAAK,GAAG,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IACjD,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,MAAM,EAAE,CAAC;QAC5C,MAAM,IAAI,KAAK,CAAC,kFAAkF,cAAc,SAAS,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IACpJ,CAAC;IACD,OAAO,EAAE,OAAO,EAAE,CAAC,CAAC,QAAQ,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,IAAI,GAAG,EAAE,OAAO,EAAE,kBAAkB,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,kBAAkB,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;AAC1I,CAAC;AAXD,wCAWC;AAED,sGAAsG;AACtG,SAAgB,iBAAiB,CAAC,GAAW;IACzC,IAAI,IAAI,GAAG,gBAAgB,CAAC,GAAG,CAAC,CAAC;IACjC,IAAI,CAAC,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,CAAC;IACtB,IAAI,KAAK,GAAG,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IACjD,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,MAAM,EAAE,CAAC;QAC5C,MAAM,IAAI,KAAK,CAAC,sFAAsF,cAAc,SAAS,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IACxJ,CAAC;IACD,OAAO,EAAE,UAAU,EAAE,kBAAkB,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;AACxD,CAAC;AARD,8CAQC;AAED,SAAgB,eAAe,CAAC,MAAwB;IACpD,IAAI,OAAO,MAAM,KAAK,QAAQ,EAAE,CAAC;QAC7B,IAAI,MAAM,GAAG,MAAM,CAAC,WAAW,CAAC;QAChC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,EAAE,CAAC;YAC7F,MAAM,IAAI,KAAK,CAAC,6OAA6O,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,OAAO,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC;QACtU,CAAC;QACD,IAAI,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;QACzB,IAAI,KAAK,KAAK,SAAS,IAAI,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;YAC3K,MAAM,IAAI,KAAK,CAAC,0FAA0F,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC;QAClL,CAAC;QACD,IAAI,MAAM,CAAC,eAAe,KAAK,SAAS,EAAE,CAAC;YACvC,IAAI,OAAO,MAAM,CAAC,eAAe,KAAK,QAAQ,IAAI,MAAM,CAAC,eAAe,IAAI,CAAC,EAAE,CAAC;gBAC5E,MAAM,IAAI,KAAK,CAAC,sDAAsD,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,eAAe,CAAC,OAAO,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC;YAC/J,CAAC;YACD,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;gBACrB,MAAM,IAAI,KAAK,CAAC,iGAAiG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC;YAC7J,CAAC;QACL,CAAC;QACD,IAAI,MAAM,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;YAC3B,oFAAoF;YACpF,cAAc,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QAC/B,CAAC;QACD,OAAO,MAAM,CAAC;IAClB,CAAC;IACD,IAAI,QAAQ,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC;IACxC,IAAI,QAAQ,CAAC,QAAQ,CAAC,kBAAkB,CAAC,EAAE,CAAC;QACxC,2FAA2F;QAC3F,2DAA2D;QAC3D,iBAAiB,CAAC,MAAM,CAAC,CAAC;QAC1B,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,EAAE,WAAW,EAAE,6BAAiB,EAAE,CAAC;IAC9E,CAAC;IACD,cAAc,CAAC,MAAM,CAAC,CAAC;IACvB,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,EAAE,WAAW,EAAE,6BAAiB,EAAE,CAAC;AAC3E,CAAC;AAjCD,0CAiCC;AAED,SAAgB,qBAAqB,CAAC,MAAuC;IACzE,IAAI,MAAoB,CAAC;IACzB,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,SAAS,IAAI,MAAM,EAAE,CAAC;QACpD,MAAM,GAAG,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,EAAE,CAAC;IACvF,CAAC;SAAM,CAAC;QACJ,MAAM,GAAG,EAAE,OAAO,EAAE,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;IACpD,CAAC;IACD,2FAA2F;IAC3F,wFAAwF;IACxF,6FAA6F;IAC7F,2FAA2F;IAC3F,kFAAkF;IAClF,IAAI,OAAO,GAAG,MAAM,CAAC,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;IAClD,IAAI,MAAM,GAAG,CAAC,GAAG,OAAO,CAAC,CAAC;IAC1B,IAAA,WAAI,EAAC,MAAM,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;IACpC,IAAI,KAAK,GAAmB,EAAE,CAAC;IAC/B,IAAI,QAAQ,GAAG,CAAC,CAAC;IACjB,SAAS,UAAU;QACf,IAAI,cAAc,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC;QAC3D,IAAI,cAAc,IAAI,cAAc,KAAK,KAAK,CAAC,MAAM,EAAE,CAAC;YACpD,MAAM,IAAI,KAAK,CAAC,sEAAsE,cAAc,OAAO,KAAK,CAAC,MAAM,4BAA4B,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,GAAG,EAAE,WAAW,EAAE,CAAC,CAAC,WAAW,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QACjQ,CAAC;QACD,0FAA0F;QAC1F,0BAA0B;QAC1B,IAAI,MAAM,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,IAAI,sBAAU,CAAC,CAAC;QACnD,IAAA,WAAI,EAAC,MAAM,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACxB,IAAI,OAAO,GAAG,CAAC,CAAC;QAChB,KAAK,IAAI,KAAK,IAAI,MAAM,EAAE,CAAC;YACvB,IAAI,KAAK,CAAC,CAAC,CAAC,GAAG,OAAO;gBAAE,MAAM;YAC9B,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QAC1C,CAAC;QACD,IAAI,OAAO,GAAG,CAAC,EAAE,CAAC;YACd,MAAM,IAAI,KAAK,CAAC,oGAAoG,OAAO,cAAc,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,GAAG,EAAE,WAAW,EAAE,CAAC,CAAC,WAAW,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,IAAI,sBAAU,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QAC3P,CAAC;IACL,CAAC;IACD,KAAK,IAAI,MAAM,IAAI,MAAM,EAAE,CAAC;QACxB,IAAI,KAAK,CAAC,MAAM,IAAI,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,QAAQ,EAAE,CAAC;YACpD,UAAU,EAAE,CAAC;YACb,KAAK,GAAG,EAAE,CAAC;QACf,CAAC;QACD,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACnB,QAAQ,GAAG,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;IACzD,CAAC;IACD,UAAU,EAAE,CAAC;IACb,OAAO,MAAM,CAAC;AAClB,CAAC;AA7CD,sDA6CC;AAED,SAAgB,gBAAgB,CAAC,IAAY;IACzC,IAAI,IAAI,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;IAC3B,IAAI,MAAoB,CAAC;IACzB,IAAI,CAAC;QACD,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAiB,CAAC;IAC9C,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACT,MAAM,IAAI,KAAK,CAAC,qCAAqC,MAAM,CAAC,CAAC,CAAC,YAAY,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC;IACpG,CAAC;IACD,IAAI,CAAC,MAAM,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC;QAC1E,MAAM,IAAI,KAAK,CAAC,4DAA4D,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,EAAE,CAAC,CAAC;IACtG,CAAC;IACD,OAAO,qBAAqB,CAAC,MAAM,CAAC,CAAC;AACzC,CAAC;AAZD,4CAYC;AAED,SAAgB,qBAAqB,CAAC,MAAoB;IACtD,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,CAAC;AAC7D,CAAC;AAFD,sDAEC","sourcesContent":["module.allowclient = true;\n\nimport { sort, sha256HashBuffer } from \"socket-function/src/misc\";\nimport { getBufferInt } from \"socket-function/src/bits\";\nimport { RemoteConfig, RemoteConfigBase, HostedConfig, BackblazeConfig, FULL_VALID_WINDOW, FULL_ROUTE, VARIABLE_SHARD } from \"../IArchives\";\n\n// Parsing / normalization of RemoteConfig (see IArchives.ts). Every bucket stores its own\n// configuration (a RemoteConfig) inside itself, at ROUTING_FILE. Writing that file creates the\n// bucket / reconfigures it (see storageServerState.ts); clients reconcile it by version (see\n// createArchives.ts).\n\nexport const ROUTING_FILE = \"storage/storagerouting.json\";\nconst ROUTING_SUFFIX = \"/\" + ROUTING_FILE;\n\nconst ROUTE_PRECISION = 1000 * 1000 * 1000;\n\n/** The variable-shard route override embedded in the key (\"<sentinel>_<value>\", see VARIABLE_SHARD), or undefined when the key has no sentinel or the sentinel has no value yet. */\nexport function parseVariableRoute(key: string): number | undefined {\n    let index = key.indexOf(VARIABLE_SHARD);\n    if (index === -1) return undefined;\n    let match = /^_(\\d+(?:\\.\\d+)?)/.exec(key.slice(index + VARIABLE_SHARD.length));\n    if (!match) return undefined;\n    return +match[1];\n}\n\n/** Where a key routes in [0, 1). A materialized variable-shard suffix completely overrides the hash. */\nexport function getRoute(key: string): number {\n    let override = parseVariableRoute(key);\n    if (override !== undefined) return override;\n    let hash = getBufferInt(sha256HashBuffer(key));\n    return hash % ROUTE_PRECISION / ROUTE_PRECISION;\n}\n\n// Route ranges are [start, end) - inclusive start, exclusive end\nexport function routeContains(route: [number, number] | undefined, value: number): boolean {\n    if (!route) return true;\n    return route[0] <= value && value < route[1];\n}\nexport function routesOverlap(a: [number, number] | undefined, b: [number, number] | undefined): boolean {\n    let [aStart, aEnd] = a || FULL_ROUTE;\n    let [bStart, bEnd] = b || FULL_ROUTE;\n    return aStart < bEnd && bStart < aEnd;\n}\n/** The overlap of two route ranges, or undefined when they don't overlap. */\nexport function routeIntersection(a: [number, number] | undefined, b: [number, number] | undefined): [number, number] | undefined {\n    let [aStart, aEnd] = a || FULL_ROUTE;\n    let [bStart, bEnd] = b || FULL_ROUTE;\n    let start = Math.max(aStart, bStart);\n    let end = Math.min(aEnd, bEnd);\n    if (start >= end) return undefined;\n    return [start, end];\n}\n\n// A missing version counts as -1, so any explicitly versioned config beats an unversioned one\nexport function getConfigVersion(config: RemoteConfig): number {\n    return config.version ?? -1;\n}\n\n/** Strips the routing-file suffix, leaving the bucket's public base URL (file paths append to it). */\nexport function getBucketBaseUrl(url: string): string {\n    if (!url.endsWith(ROUTING_SUFFIX)) {\n        throw new Error(`Expected a bucket routing URL ending with ${JSON.stringify(ROUTING_SUFFIX)}, was ${JSON.stringify(url)}`);\n    }\n    return url.slice(0, -ROUTING_SUFFIX.length);\n}\n\nexport function buildFileUrl(baseUrl: string, filePath: string): string {\n    return baseUrl + \"/\" + filePath.split(\"/\").map(encodeURIComponent).join(\"/\");\n}\n\n// Ex: https://storage2.vidgridweb.com:4445/file/exampleaccount/examplebucket/storage/storagerouting.json\nexport function parseHostedUrl(url: string): { address: string; port: number; account: string; bucketName: string } {\n    let base = getBucketBaseUrl(url);\n    let u = new URL(base);\n    if (u.protocol !== \"https:\") {\n        throw new Error(`Storage URL must use https, got ${JSON.stringify(u.protocol)} in ${JSON.stringify(url)}`);\n    }\n    let parts = u.pathname.split(\"/\").filter(x => x);\n    if (parts.length !== 3 || parts[0] !== \"file\") {\n        throw new Error(`Expected a hosted bucket URL like https://host:port/file/<account>/<bucketName>${ROUTING_SUFFIX}, was ${JSON.stringify(url)}`);\n    }\n    return { address: u.hostname, port: +u.port || 443, account: decodeURIComponent(parts[1]), bucketName: decodeURIComponent(parts[2]) };\n}\n\n// Ex: https://f002.backblazeb2.com/file/querysubtest-com-public-immutable/storage/storagerouting.json\nexport function parseBackblazeUrl(url: string): { bucketName: string } {\n    let base = getBucketBaseUrl(url);\n    let u = new URL(base);\n    let parts = u.pathname.split(\"/\").filter(x => x);\n    if (parts.length !== 2 || parts[0] !== \"file\") {\n        throw new Error(`Expected a backblaze bucket URL like https://f002.backblazeb2.com/file/<bucketName>${ROUTING_SUFFIX}, was ${JSON.stringify(url)}`);\n    }\n    return { bucketName: decodeURIComponent(parts[1]) };\n}\n\nexport function normalizeSource(source: RemoteConfigBase): HostedConfig | BackblazeConfig {\n    if (typeof source !== \"string\") {\n        let window = source.validWindow;\n        if (!Array.isArray(window) || window.length !== 2 || !window.every(x => typeof x === \"number\")) {\n            throw new Error(`Object source configs must specify validWindow ([startMs, endMs] of the write times the source is valid for) - configuration changes must be scheduled, not flipped instantly. Use FULL_VALID_WINDOW when the source is always valid. Was ${JSON.stringify(window)} on ${JSON.stringify(source).slice(0, 500)}`);\n        }\n        let route = source.route;\n        if (route !== undefined && (!Array.isArray(route) || route.length !== 2 || !route.every(x => typeof x === \"number\") || route[0] < 0 || route[1] > 1 || route[0] >= route[1])) {\n            throw new Error(`Source route must be a [start, end) fraction range within [0, 1] with start < end, was ${JSON.stringify(route)} on ${JSON.stringify(source).slice(0, 500)}`);\n        }\n        if (source.readerDiskLimit !== undefined) {\n            if (typeof source.readerDiskLimit !== \"number\" || source.readerDiskLimit <= 0) {\n                throw new Error(`readerDiskLimit must be a positive byte count, was ${JSON.stringify(source.readerDiskLimit)} on ${JSON.stringify(source).slice(0, 500)}`);\n            }\n            if (!source.noFullSync) {\n                throw new Error(`readerDiskLimit requires noFullSync: a full copy cannot be bounded, only a read cache can. On ${JSON.stringify(source).slice(0, 500)}`);\n            }\n        }\n        if (source.type === \"remote\") {\n            // Throws if the URL is malformed, so bad configs are rejected before they're stored\n            parseHostedUrl(source.url);\n        }\n        return source;\n    }\n    let hostname = new URL(source).hostname;\n    if (hostname.endsWith(\".backblazeb2.com\")) {\n        // Validates the URL (throws on malformed) before it's stored; the bucket name is read back\n        // out of the URL at use sites, never stored on the config.\n        parseBackblazeUrl(source);\n        return { type: \"backblaze\", url: source, validWindow: FULL_VALID_WINDOW };\n    }\n    parseHostedUrl(source);\n    return { type: \"remote\", url: source, validWindow: FULL_VALID_WINDOW };\n}\n\nexport function normalizeRemoteConfig(config: RemoteConfig | RemoteConfigBase): RemoteConfig {\n    let result: RemoteConfig;\n    if (typeof config !== \"string\" && \"sources\" in config) {\n        result = { version: config.version, sources: config.sources.map(normalizeSource) };\n    } else {\n        result = { sources: [normalizeSource(config)] };\n    }\n    // Mixed immutability makes no sense AMONG sources valid at the same time: a mutable source\n    // would accept overwrites that its immutable peers refuse to synchronize, forking their\n    // contents. Sources are grouped by transitively overlapping valid windows (absorb everything\n    // overlapping the group, extend the group's end, repeat) - a soft check that is correct as\n    // long as windows have clean breaks (a group ends exactly where the next begins).\n    let sources = result.sources.map(normalizeSource);\n    let sorted = [...sources];\n    sort(sorted, x => x.validWindow[0]);\n    let group: typeof sources = [];\n    let groupEnd = 0;\n    function checkGroup() {\n        let immutableCount = group.filter(x => x.immutable).length;\n        if (immutableCount && immutableCount !== group.length) {\n            throw new Error(`Sources with overlapping valid windows must agree on immutability: ${immutableCount} of ${group.length} are immutable. Sources: ${JSON.stringify(group.map(x => ({ url: x.url, validWindow: x.validWindow, immutable: !!x.immutable })))}`);\n        }\n        // The sources valid at any instant must cover the whole key space, or keys routing into a\n        // gap could never be read\n        let routes = group.map(x => x.route || FULL_ROUTE);\n        sort(routes, x => x[0]);\n        let covered = 0;\n        for (let route of routes) {\n            if (route[0] > covered) break;\n            covered = Math.max(covered, route[1]);\n        }\n        if (covered < 1) {\n            throw new Error(`Sources with overlapping valid windows must cover the full route space [0, 1); coverage stops at ${covered}. Sources: ${JSON.stringify(group.map(x => ({ url: x.url, validWindow: x.validWindow, route: x.route || FULL_ROUTE })))}`);\n        }\n    }\n    for (let source of sorted) {\n        if (group.length && source.validWindow[0] >= groupEnd) {\n            checkGroup();\n            group = [];\n        }\n        group.push(source);\n        groupEnd = Math.max(groupEnd, source.validWindow[1]);\n    }\n    checkGroup();\n    return result;\n}\n\nexport function parseRoutingData(data: Buffer): RemoteConfig {\n    let text = data.toString();\n    let parsed: RemoteConfig;\n    try {\n        parsed = JSON.parse(text) as RemoteConfig;\n    } catch (e) {\n        throw new Error(`Routing config is not valid JSON (${String(e)}). Data: ${text.slice(0, 500)}`);\n    }\n    if (!parsed || typeof parsed !== \"object\" || !Array.isArray(parsed.sources)) {\n        throw new Error(`Routing config must be { version?, sources: [...] }, was ${text.slice(0, 500)}`);\n    }\n    return normalizeRemoteConfig(parsed);\n}\n\nexport function serializeRemoteConfig(config: RemoteConfig): Buffer {\n    return Buffer.from(JSON.stringify(config, undefined, 4));\n}\n"]}
- /* _JS_SOURCE_HASH = "3a7b4001ca69930ddc2d211daa61b2c9ba6c78217ad2d7e2d7e5cd2ae549d03a"; */
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"remoteConfig.js","sourceRoot":"","sources":["remoteConfig.ts"],"names":[],"mappings":"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","sourcesContent":["module.allowclient = true;\n\nimport { sort, sha256HashBuffer } from \"socket-function/src/misc\";\nimport { getBufferInt } from \"socket-function/src/bits\";\nimport { RemoteConfig, RemoteConfigBase, HostedConfig, BackblazeConfig, FULL_VALID_WINDOW, FULL_ROUTE, VARIABLE_SHARD } from \"../IArchives\";\n\n// Parsing / normalization of RemoteConfig (see IArchives.ts). Every bucket stores its own\n// configuration (a RemoteConfig) inside itself, at ROUTING_FILE. Writing that file creates the\n// bucket / reconfigures it (see storageServerState.ts); clients reconcile it by version (see\n// createArchives.ts).\n\nexport const ROUTING_FILE = \"storage/storagerouting.json\";\nconst ROUTING_SUFFIX = \"/\" + ROUTING_FILE;\n\nconst ROUTE_PRECISION = 1000 * 1000 * 1000;\n\n/** The variable-shard route override embedded in the key (\"<sentinel>_<value>\", see VARIABLE_SHARD), or undefined when the key has no sentinel or the sentinel has no value yet. */\nexport function parseVariableRoute(key: string): number | undefined {\n    let index = key.indexOf(VARIABLE_SHARD);\n    if (index === -1) return undefined;\n    let match = /^_(\\d+(?:\\.\\d+)?)/.exec(key.slice(index + VARIABLE_SHARD.length));\n    if (!match) return undefined;\n    return +match[1];\n}\n\n/** Where a key routes in [0, 1). A materialized variable-shard suffix completely overrides the hash. */\nexport function getRoute(key: string): number {\n    let override = parseVariableRoute(key);\n    if (override !== undefined) return override;\n    let hash = getBufferInt(sha256HashBuffer(key));\n    return hash % ROUTE_PRECISION / ROUTE_PRECISION;\n}\n\n// Route ranges are [start, end) - inclusive start, exclusive end\nexport function routeContains(route: [number, number] | undefined, value: number): boolean {\n    if (!route) return true;\n    return route[0] <= value && value < route[1];\n}\nexport function routesOverlap(a: [number, number] | undefined, b: [number, number] | undefined): boolean {\n    let [aStart, aEnd] = a || FULL_ROUTE;\n    let [bStart, bEnd] = b || FULL_ROUTE;\n    return aStart < bEnd && bStart < aEnd;\n}\n/** The overlap of two route ranges, or undefined when they don't overlap. */\nexport function routeIntersection(a: [number, number] | undefined, b: [number, number] | undefined): [number, number] | undefined {\n    let [aStart, aEnd] = a || FULL_ROUTE;\n    let [bStart, bEnd] = b || FULL_ROUTE;\n    let start = Math.max(aStart, bStart);\n    let end = Math.min(aEnd, bEnd);\n    if (start >= end) return undefined;\n    return [start, end];\n}\n\n// A missing version counts as -1, so any explicitly versioned config beats an unversioned one\nexport function getConfigVersion(config: RemoteConfig): number {\n    return config.version ?? -1;\n}\n\n/** Strips the routing-file suffix, leaving the bucket's public base URL (file paths append to it). */\nexport function getBucketBaseUrl(url: string): string {\n    if (!url.endsWith(ROUTING_SUFFIX)) {\n        throw new Error(`Expected a bucket routing URL ending with ${JSON.stringify(ROUTING_SUFFIX)}, was ${JSON.stringify(url)}`);\n    }\n    return url.slice(0, -ROUTING_SUFFIX.length);\n}\n\nexport function buildFileUrl(baseUrl: string, filePath: string): string {\n    return baseUrl + \"/\" + filePath.split(\"/\").map(encodeURIComponent).join(\"/\");\n}\n\n// Ex: https://storage2.vidgridweb.com:4445/file/exampleaccount/examplebucket/storage/storagerouting.json\nexport function parseHostedUrl(url: string): { address: string; port: number; account: string; bucketName: string } {\n    let base = getBucketBaseUrl(url);\n    let u = new URL(base);\n    if (u.protocol !== \"https:\") {\n        throw new Error(`Storage URL must use https, got ${JSON.stringify(u.protocol)} in ${JSON.stringify(url)}`);\n    }\n    let parts = u.pathname.split(\"/\").filter(x => x);\n    if (parts.length !== 3 || parts[0] !== \"file\") {\n        throw new Error(`Expected a hosted bucket URL like https://host:port/file/<account>/<bucketName>${ROUTING_SUFFIX}, was ${JSON.stringify(url)}`);\n    }\n    return { address: u.hostname, port: +u.port || 443, account: decodeURIComponent(parts[1]), bucketName: decodeURIComponent(parts[2]) };\n}\n\n// Ex: https://f002.backblazeb2.com/file/querysubtest-com-public-immutable/storage/storagerouting.json\nexport function parseBackblazeUrl(url: string): { bucketName: string } {\n    let base = getBucketBaseUrl(url);\n    let u = new URL(base);\n    let parts = u.pathname.split(\"/\").filter(x => x);\n    if (parts.length !== 2 || parts[0] !== \"file\") {\n        throw new Error(`Expected a backblaze bucket URL like https://f002.backblazeb2.com/file/<bucketName>${ROUTING_SUFFIX}, was ${JSON.stringify(url)}`);\n    }\n    return { bucketName: decodeURIComponent(parts[1]) };\n}\n\nexport function replaceHostedUrlPort(url: string, port: number): string {\n    let u = new URL(url);\n    u.port = String(port);\n    return u.toString();\n}\n\nexport function normalizeSource(source: RemoteConfigBase): HostedConfig | BackblazeConfig {\n    if (typeof source !== \"string\") {\n        let window = source.validWindow;\n        if (!Array.isArray(window) || window.length !== 2 || !window.every(x => typeof x === \"number\")) {\n            throw new Error(`Object source configs must specify validWindow ([startMs, endMs] of the write times the source is valid for) - configuration changes must be scheduled, not flipped instantly. Use FULL_VALID_WINDOW when the source is always valid. Was ${JSON.stringify(window)} on ${JSON.stringify(source).slice(0, 500)}`);\n        }\n        let route = source.route;\n        if (route !== undefined && (!Array.isArray(route) || route.length !== 2 || !route.every(x => typeof x === \"number\") || route[0] < 0 || route[1] > 1 || route[0] >= route[1])) {\n            throw new Error(`Source route must be a [start, end) fraction range within [0, 1] with start < end, was ${JSON.stringify(route)} on ${JSON.stringify(source).slice(0, 500)}`);\n        }\n        if (source.readerDiskLimit !== undefined) {\n            if (typeof source.readerDiskLimit !== \"number\" || source.readerDiskLimit <= 0) {\n                throw new Error(`readerDiskLimit must be a positive byte count, was ${JSON.stringify(source.readerDiskLimit)} on ${JSON.stringify(source).slice(0, 500)}`);\n            }\n            if (!source.noFullSync) {\n                throw new Error(`readerDiskLimit requires noFullSync: a full copy cannot be bounded, only a read cache can. On ${JSON.stringify(source).slice(0, 500)}`);\n            }\n        }\n        if (source.type === \"remote\") {\n            // Throws if the URL is malformed, so bad configs are rejected before they're stored\n            parseHostedUrl(source.url);\n        }\n        return source;\n    }\n    let hostname = new URL(source).hostname;\n    if (hostname.endsWith(\".backblazeb2.com\")) {\n        // Validates the URL (throws on malformed) before it's stored; the bucket name is read back\n        // out of the URL at use sites, never stored on the config.\n        parseBackblazeUrl(source);\n        return { type: \"backblaze\", url: source, validWindow: FULL_VALID_WINDOW };\n    }\n    parseHostedUrl(source);\n    return { type: \"remote\", url: source, validWindow: FULL_VALID_WINDOW };\n}\n\nexport function normalizeRemoteConfig(config: RemoteConfig | RemoteConfigBase): RemoteConfig {\n    let result: RemoteConfig;\n    if (typeof config !== \"string\" && \"sources\" in config) {\n        result = { version: config.version, sources: config.sources.map(normalizeSource) };\n    } else {\n        result = { sources: [normalizeSource(config)] };\n    }\n    // Mixed immutability makes no sense AMONG sources valid at the same time: a mutable source\n    // would accept overwrites that its immutable peers refuse to synchronize, forking their\n    // contents. Sources are grouped by transitively overlapping valid windows (absorb everything\n    // overlapping the group, extend the group's end, repeat) - a soft check that is correct as\n    // long as windows have clean breaks (a group ends exactly where the next begins).\n    let sources = result.sources.map(normalizeSource);\n    let sorted = [...sources];\n    sort(sorted, x => x.validWindow[0]);\n    let group: typeof sources = [];\n    let groupEnd = 0;\n    function checkGroup() {\n        let immutableCount = group.filter(x => x.immutable).length;\n        if (immutableCount && immutableCount !== group.length) {\n            throw new Error(`Sources with overlapping valid windows must agree on immutability: ${immutableCount} of ${group.length} are immutable. Sources: ${JSON.stringify(group.map(x => ({ url: x.url, validWindow: x.validWindow, immutable: !!x.immutable })))}`);\n        }\n        // The sources valid at any instant must cover the whole key space, or keys routing into a\n        // gap could never be read\n        let routes = group.map(x => x.route || FULL_ROUTE);\n        sort(routes, x => x[0]);\n        let covered = 0;\n        for (let route of routes) {\n            if (route[0] > covered) break;\n            covered = Math.max(covered, route[1]);\n        }\n        if (covered < 1) {\n            throw new Error(`Sources with overlapping valid windows must cover the full route space [0, 1); coverage stops at ${covered}. Sources: ${JSON.stringify(group.map(x => ({ url: x.url, validWindow: x.validWindow, route: x.route || FULL_ROUTE })))}`);\n        }\n    }\n    for (let source of sorted) {\n        if (group.length && source.validWindow[0] >= groupEnd) {\n            checkGroup();\n            group = [];\n        }\n        group.push(source);\n        groupEnd = Math.max(groupEnd, source.validWindow[1]);\n    }\n    checkGroup();\n    return result;\n}\n\nexport function parseRoutingData(data: Buffer): RemoteConfig {\n    let text = data.toString();\n    let parsed: RemoteConfig;\n    try {\n        parsed = JSON.parse(text) as RemoteConfig;\n    } catch (e) {\n        throw new Error(`Routing config is not valid JSON (${String(e)}). Data: ${text.slice(0, 500)}`);\n    }\n    if (!parsed || typeof parsed !== \"object\" || !Array.isArray(parsed.sources)) {\n        throw new Error(`Routing config must be { version?, sources: [...] }, was ${text.slice(0, 500)}`);\n    }\n    return normalizeRemoteConfig(parsed);\n}\n\nexport function serializeRemoteConfig(config: RemoteConfig): Buffer {\n    return Buffer.from(JSON.stringify(config, undefined, 4));\n}\n"]}
+ /* _JS_SOURCE_HASH = "74b88ee67a0e83e047adda50a28b23d34b59b4a31e42c9153d90a6d3f6b03a5a"; */