sliftutils 1.7.10 → 1.7.12

package/storage/dist/backblaze.ts.cache

@@ -0,0 +1,797 @@
+"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.getArchivesBackblazePublic = exports.getArchivesBackblazePublicImmutable = exports.getArchivesBackblazePrivateImmutable = exports.getArchivesBackblaze = exports.ArchivesBackblaze = void 0;
+const caching_1 = require("socket-function/src/caching");
+const misc_1 = require("socket-function/src/misc");
+const batching_1 = require("socket-function/src/batching");
+const format_1 = require("socket-function/src/formatting/format");
+const logColors_1 = require("socket-function/src/formatting/logColors");
+const dns_1 = __importDefault(require("dns"));
+const getSecret_1 = require("../misc/getSecret");
+const https_1 = require("socket-function/src/https");
+const IArchives_1 = require("./IArchives");
+let backblazeCreds = (0, caching_1.lazy)(async () => {
+    let keyId = await (0, getSecret_1.getSecret)("backblaze.json.applicationKeyId");
+    let key = await (0, getSecret_1.getSecret)("backblaze.json.applicationKey");
+    return {
+        applicationKeyId: keyId,
+        applicationKey: key,
+    };
+});
+const getAPI = (0, caching_1.lazy)(async () => {
+    let creds = await backblazeCreds();
+    // NOTE: On errors, our retry code resets this lazy, so we DO get new authorize when needed.
+    // TODO: Maybe we should get new authorization periodically at well?
+    let authorizeRaw = await (0, https_1.httpsRequest)("https://api.backblazeb2.com/b2api/v2/b2_authorize_account", undefined, "GET", undefined, {
+        headers: {
+            Authorization: "Basic " + Buffer.from(creds.applicationKeyId + ":" + creds.applicationKey).toString("base64"),
+        }
+    });
+    let auth = JSON.parse(authorizeRaw.toString());
+    function createB2Function(name, type, noAccountId) {
+        return async (arg) => {
+            if (!noAccountId) {
+                arg = { accountId: auth.accountId, ...arg };
+            }
+            try {
+                let url = auth.apiUrl + "/b2api/v2/" + name;
+                let result = await (0, https_1.httpsRequest)(url, Buffer.from(JSON.stringify(arg)), type, undefined, {
+                    headers: {
+                        Authorization: auth.authorizationToken,
+                    }
+                });
+                return JSON.parse(result.toString());
+            }
+            catch (e) {
+                throw new Error(`Error in ${name}, arg ${JSON.stringify(arg).slice(0, 1000)}: ${e.stack}`);
+            }
+        };
+    }
+    const createBucket = createB2Function("b2_create_bucket", "POST");
+    const updateBucket = createB2Function("b2_update_bucket", "POST");
+    // https://www.backblaze.com/apidocs/b2-update-bucket
+    //  TODO: b2_update_bucket, so we can update CORS, etc
+    const listBuckets = createB2Function("b2_list_buckets", "POST");
+    function encodePath(path) {
+        // Preserve slashes, but encode everything else
+        path = path.split("/").map(encodeURIComponent).join("/");
+        if (path.startsWith("/"))
+            path = "%2F" + path.slice(1);
+        if (path.endsWith("/"))
+            path = path.slice(0, -1) + "%2F";
+        // NOTE: For some reason, this won't render in the web UI correctly. BUT, it'll
+        //  work get get/set and find
+        //  - ALSO, it seems to add duplicate files? This might also be a web UI thing. It
+        //      seems to work though.
+        while (path.includes("//")) {
+            path = path.replaceAll("//", "/%2F");
+        }
+        return path;
+    }
+    async function downloadFileByName(config) {
+        let fileName = encodePath(config.fileName);
+        let result = await (0, https_1.httpsRequest)(auth.apiUrl + "/file/" + config.bucketName + "/" + fileName, Buffer.from(JSON.stringify({
+            accountId: auth.accountId,
+            responseType: "arraybuffer",
+        })), "GET", undefined, {
+            headers: Object.fromEntries(Object.entries({
+                Authorization: auth.authorizationToken,
+                "Content-Type": "application/json",
+                Range: config.range ? `bytes=${config.range.start}-${config.range.end - 1}` : undefined,
+            }).filter(x => x[1] !== undefined)),
+        });
+        return result;
+    }
+    // Oh... apparently, we can't reuse these? Huh...
+    const getUploadURL = (async (bucketId) => {
+        //setTimeout(() => getUploadURL.clear(bucketId), timeInHour * 1);
+        let getUploadUrlRaw = await (0, https_1.httpsRequest)(auth.apiUrl + "/b2api/v2/b2_get_upload_url?bucketId=" + bucketId, undefined, "GET", undefined, {
+            headers: {
+                Authorization: auth.authorizationToken,
+            }
+        });
+        return JSON.parse(getUploadUrlRaw.toString());
+    });
+    async function uploadFile(config) {
+        let getUploadUrl = await getUploadURL(config.bucketId);
+        await (0, https_1.httpsRequest)(getUploadUrl.uploadUrl, config.data, "POST", undefined, {
+            headers: {
+                Authorization: getUploadUrl.authorizationToken,
+                "X-Bz-File-Name": encodePath(config.fileName),
+                "Content-Type": "b2/x-auto",
+                "X-Bz-Content-Sha1": "do_not_verify",
+                "Content-Length": config.data.length + "",
+            }
+        });
+    }
+    const hideFile = createB2Function("b2_hide_file", "POST", "noAccountId");
+    const getFileInfo = createB2Function("b2_get_file_info", "POST", "noAccountId");
+    const listFileNames = createB2Function("b2_list_file_names", "POST", "noAccountId");
+    const copyFile = createB2Function("b2_copy_file", "POST", "noAccountId");
+    const startLargeFile = createB2Function("b2_start_large_file", "POST", "noAccountId");
+    // Apparently we can't reuse these?
+    const getUploadPartURL = (async (fileId) => {
+        let uploadPartRaw = await (0, https_1.httpsRequest)(auth.apiUrl + "/b2api/v2/b2_get_upload_part_url?fileId=" + fileId, undefined, "GET", undefined, {
+            headers: {
+                Authorization: auth.authorizationToken,
+            }
+        });
+        return JSON.parse(uploadPartRaw.toString());
+    });
+    async function uploadPart(config) {
+        let uploadPart = await getUploadPartURL(config.fileId);
+        let result = await (0, https_1.httpsRequest)(uploadPart.uploadUrl, config.data, "POST", undefined, {
+            headers: {
+                Authorization: uploadPart.authorizationToken,
+                "X-Bz-Part-Number": config.partNumber + "",
+                "X-Bz-Content-Sha1": config.sha1,
+                "Content-Length": config.data.length + "",
+            }
+        });
+        return JSON.parse(result.toString());
+    }
+    const finishLargeFile = createB2Function("b2_finish_large_file", "POST", "noAccountId");
+    const cancelLargeFile = createB2Function("b2_cancel_large_file", "POST", "noAccountId");
+    const getDownloadAuthorization = createB2Function("b2_get_download_authorization", "POST", "noAccountId");
+    async function getDownloadURL(path) {
+        if (!path.startsWith("/")) {
+            path = "/" + path;
+        }
+        return auth.downloadUrl + path;
+    }
+    return {
+        createBucket,
+        updateBucket,
+        listBuckets,
+        downloadFileByName,
+        uploadFile,
+        hideFile,
+        getFileInfo,
+        listFileNames,
+        copyFile,
+        startLargeFile,
+        uploadPart,
+        finishLargeFile,
+        cancelLargeFile,
+        getDownloadAuthorization,
+        getDownloadURL,
+        apiUrl: auth.apiUrl,
+        allowed: auth.allowed,
+    };
+});
+class ArchivesBackblaze {
+    constructor(config) {
+        this.config = config;
+        this.bucketName = this.config.bucketName.replaceAll(/[^\w\d]/g, "-");
+        this.bucketId = "";
+        this.logging = false;
+        this.getBucketAPI = (0, caching_1.lazy)(async () => {
+            var _a, _b;
+            let api = await getAPI();
+            let cacheTime = (_a = this.config.cacheTime) !== null && _a !== void 0 ? _a : 0;
+            if (this.config.immutable) {
+                cacheTime = IArchives_1.IMMUTABLE_CACHE_TIME;
+            }
+            // ALWAYS set access control, as we can make urls for private buckets with getDownloadAuthorization
+            let desiredCorsRules = [{
+                    corsRuleName: "allowAll",
+                    allowedOrigins: (_b = this.config.allowedOrigins) !== null && _b !== void 0 ? _b : ["https"],
+                    allowedOperations: ["b2_download_file_by_id", "b2_download_file_by_name"],
+                    allowedHeaders: ["range"],
+                    exposeHeaders: ["x-bz-content-sha1"],
+                    maxAgeSeconds: cacheTime / 1000,
+                }];
+            let bucketInfo = {};
+            if (cacheTime) {
+                bucketInfo["cache-control"] = `max-age=${cacheTime / 1000}`;
+            }
+            let exists = false;
+            let retries = 0;
+            while (true) {
+                try {
+                    await api.createBucket({
+                        bucketName: this.bucketName,
+                        bucketType: this.config.public ? "allPublic" : "allPrivate",
+                        lifecycleRules: [{
+                                "daysFromUploadingToHiding": null,
+                                // Keep files for 7 days, which should be enough time to recover accidental hiding.
+                                "daysFromHidingToDeleting": 7,
+                                "fileNamePrefix": ""
+                            }],
+                        corsRules: desiredCorsRules,
+                        bucketInfo
+                    });
+                }
+                catch (e) {
+                    if (!e.stack.includes(`"duplicate_bucket_name"`)) {
+                        if (retries < 3) {
+                            console.error(`Backblaze create bucket failed, retrying in 5s: ${e.stack}`);
+                            await (0, batching_1.delay)(5000);
+                            retries++;
+                            continue;
+                        }
+                        throw e;
+                    }
+                    exists = true;
+                }
+                break;
+            }
+            let bucketList = await api.listBuckets({
+                bucketName: this.bucketName,
+            });
+            if (bucketList.buckets.length === 0) {
+                throw new Error(`Bucket name "${this.bucketName}" is being used by someone else. Bucket names have to be globally unique. Try a different name until you find a free one.`);
+            }
+            this.bucketId = bucketList.buckets[0].bucketId;
+            if (exists) {
+                let bucket = bucketList.buckets[0];
+                function normalize(obj) {
+                    let kvps = Object.entries(obj);
+                    (0, misc_1.sort)(kvps, x => x[0]);
+                    return Object.fromEntries(kvps);
+                }
+                function orderIndependentEqual(lhs, rhs) {
+                    return JSON.stringify(normalize(lhs)) === JSON.stringify(normalize(rhs));
+                }
+                function orderIndependentEqualArray(lhs, rhs) {
+                    if (lhs.length !== rhs.length)
+                        return false;
+                    for (let i = 0; i < lhs.length; i++) {
+                        if (!orderIndependentEqual(lhs[i], rhs[i]))
+                            return false;
+                    }
+                    return true;
+                }
+                if (!orderIndependentEqualArray(bucket.corsRules, desiredCorsRules)
+                    || !orderIndependentEqual(bucket.bucketInfo, bucketInfo)) {
+                    console.log((0, logColors_1.magenta)(`Updating CORS rules for ${this.bucketName}`), bucket.corsRules, desiredCorsRules);
+                    await api.updateBucket({
+                        accountId: bucket.accountId,
+                        bucketId: bucket.bucketId,
+                        bucketType: bucket.bucketType,
+                        lifecycleRules: bucket.lifecycleRules,
+                        corsRules: desiredCorsRules,
+                        bucketInfo: bucketInfo,
+                    });
+                }
+            }
+            return api;
+        });
+        // Keep track of when we last reset because of a 503
+        this.last503Reset = 0;
+        // Get the api, to setup cors
+        void this.getBucketAPI();
+    }
+    enableLogging() {
+        this.logging = true;
+    }
+    log(text) {
+        if (!this.logging)
+            return;
+        console.log(text);
+    }
+    getDebugName() {
+        return "backblaze/" + this.config.bucketName;
+    }
+    // IMPORTANT! We must always CATCH AROUND the apiRetryLogic, NEVER inside of fnc. Otherwise we won't
+    //  be able to recreate the auth token.
+    //  `context` is a short label (verb + file path) included in every retry/error log so a stuck
+    //   silent-retry loop is identifiable from the logs.
+    async apiRetryLogic(context, fnc, retries = 3) {
+        let api;
+        try {
+            api = await this.getBucketAPI();
+            return await fnc(api);
+        }
+        catch (err) {
+            if (retries <= 0)
+                throw err;
+            // If it's a 503 and it's been a minute since we last reset, then Wait and reset.
+            if ((err.stack.includes(`"status": 503`)
+                || err.stack.includes(`"service_unavailable"`)
+                || err.stack.includes(`"internal_error"`)
+                || err.stack.includes(`ENOBUFS`)) && Date.now() - this.last503Reset > 60 * 1000) {
+                // Backblaze is so flaky that we're just going to warn here.
+                console.warn(`[${context}] Backblaze error, waiting and resetting: ${err.message}`);
+                this.log(`[${context}] Backblaze error, waiting and resetting: ${err.message}`);
+                this.currentReset = this.currentReset || (async () => {
+                    await (0, batching_1.delay)(10 * 1000);
+                    // We check again in case, and in the very likely case that this is being run in parallel, we only want to reset once.
+                    if (Date.now() - this.last503Reset > 60 * 1000) {
+                        this.log(`[${context}] Resetting getAPI and getBucketAPI: ${err.message}`);
+                        this.last503Reset = Date.now();
+                        getAPI.reset();
+                        this.getBucketAPI.reset();
+                    }
+                })().finally(() => this.currentReset = undefined);
+                await this.currentReset;
+                return this.apiRetryLogic(context, fnc, retries - 1);
+            }
+            // If the error is that the authorization token is invalid, reset getBucketAPI and getAPI
+            // If the error is that the bucket isn't found, reset getBucketAPI
+            if (err.stack.includes(`"expired_auth_token"`)) {
+                this.log(`[${context}] Authorization token expired`);
+                getAPI.reset();
+                this.getBucketAPI.reset();
+                return this.apiRetryLogic(context, fnc, retries - 1);
+            }
+            if (err.stack.includes(`no tomes available`)
+                || err.stack.includes(`ETIMEDOUT`)
+                || err.stack.includes(`socket hang up`)
+                // Eh... this might be bad, but... I think we just get random 400 errors. If this spams errors,
+                //  we can remove this line.
+                || err.stack.includes(`400 Bad Request`)
+                || err.stack.includes(`getaddrinfo ENOTFOUND`)
+                || err.stack.includes(`ECONNRESET`)
+                || err.stack.includes(`ECONNREFUSED`)
+                || err.stack.includes(`ENOBUFS`)) {
+                console.warn(`[${context}] Retrying in 5s: ${err.message}`);
+                this.log(`[${context}] ${err.message} retrying in 5s`);
+                await (0, batching_1.delay)(5000);
+                return this.apiRetryLogic(context, fnc, retries - 1);
+            }
+            if (err.stack.includes(`getaddrinfo ENOTFOUND`)) {
+                if (api) {
+                    let urlObj = new URL(api.apiUrl);
+                    let hostname = urlObj.hostname;
+                    let lookupAddresses = await new Promise(resolve => {
+                        dns_1.default.lookup(hostname, (err, addresses) => {
+                            resolve(addresses);
+                        });
+                    });
+                    let resolveAddresses = await new Promise(resolve => {
+                        dns_1.default.resolve4(hostname, (err, addresses) => {
+                            resolve(addresses);
+                        });
+                    });
+                    console.error(`[${context}] getaddrinfo ENOTFOUND ${hostname}`, { lookupAddresses, resolveAddresses, apiUrl: api.apiUrl, fullError: err.stack });
+                }
+            }
+            throw err;
+        }
+    }
+    async get(fileName, config) {
+        let downloading = true;
+        try {
+            let time = Date.now();
+            const downloadPoll = () => {
+                if (!downloading)
+                    return;
+                this.log(`Backblaze download in progress ${fileName}`);
+                setTimeout(downloadPoll, 5000);
+            };
+            setTimeout(downloadPoll, 5000);
+            let result = await this.apiRetryLogic(`get ${fileName}`, async (api) => {
+                let range = config === null || config === void 0 ? void 0 : config.range;
+                if (range) {
+                    let fileInfo = await this.getInfo(fileName);
+                    if (!fileInfo)
+                        throw new Error(`File ${fileName} not found`);
+                    let rangeStart = range.start;
+                    let rangeEnd = Math.min(range.end, fileInfo.size);
+                    // NOTE: I think if we request nothing, it confuses Backblaze and ends up giving us the entire file.
+                    if (rangeEnd <= rangeStart)
+                        return Buffer.alloc(0);
+                    let result = await api.downloadFileByName({
+                        bucketName: this.bucketName,
+                        fileName,
+                        range: { start: rangeStart, end: rangeEnd },
+                    });
+                    if (result.length !== rangeEnd - rangeStart) {
+                        console.error(`Backblaze range download returned the wrong number of bytes. Tried to get ${rangeStart}-${rangeEnd}, but received ${rangeStart}-${rangeStart + result.length}. For file: ${fileName}`);
+                    }
+                    return result;
+                }
+                return await api.downloadFileByName({
+                    bucketName: this.bucketName,
+                    fileName,
+                });
+            });
+            let timeStr = (0, format_1.formatTime)(Date.now() - time);
+            let rateStr = (0, format_1.formatNumber)(result.length / (Date.now() - time) * 1000) + "B/s";
+            this.log(`backblaze download (${(0, format_1.formatNumber)(result.length)}B${(config === null || config === void 0 ? void 0 : config.range) && `, ${(0, format_1.formatNumber)(config.range.start)} - ${(0, format_1.formatNumber)(config.range.end)}` || ""}) in ${timeStr} (${rateStr}, ${fileName})`);
+            return result;
+        }
+        catch (e) {
+            this.log(`backblaze file does not exist ${fileName}`);
+            return undefined;
+        }
+        finally {
+            downloading = false;
+        }
+    }
+    async get2(fileName, config) {
+        // B2 downloads don't return the upload time, so this takes a second API call
+        let [data, info] = await Promise.all([this.get(fileName, config), this.getInfo(fileName)]);
+        if (!data || !info)
+            return undefined;
+        return { data, writeTime: info.writeTime, size: info.size };
+    }
+    async getConfig() {
+        return {};
+    }
+    async hasWriteAccess() {
+        var _a;
+        try {
+            let api = await getAPI();
+            // B2 v2 documents allowed as a single object; our type says a list - handle both
+            let allowedRaw = api.allowed;
+            let allowedList = (Array.isArray(allowedRaw) && allowedRaw || [allowedRaw]);
+            return allowedList.some(allowed => allowed.capabilities.includes("writeFiles")
+                && (!allowed.bucketName || allowed.bucketName === this.bucketName));
+        }
+        catch (e) {
+            // No / invalid credentials
+            this.log(`backblaze hasWriteAccess check failed: ${(_a = e.stack) !== null && _a !== void 0 ? _a : e}`);
+            return false;
+        }
+    }
+    async set(fileName, data, config) {
+        if (config === null || config === void 0 ? void 0 : config.lastModified) {
+            (0, IArchives_1.assertValidLastModified)(config.lastModified);
+            let existing = await this.getInfo(fileName);
+            // An older write never overwrites a newer one (see IArchives.set). B2 stamps its own
+            // upload time, so the exact lastModified is not preserved on the stored file.
+            if (existing && config.lastModified < existing.writeTime)
+                return;
+        }
+        this.log(`backblaze upload (${(0, format_1.formatNumber)(data.length)}B) ${fileName}`);
+        let f = fileName;
+        await this.apiRetryLogic(`uploadFile ${fileName}`, async (api) => {
+            await api.uploadFile({ bucketId: this.bucketId, fileName, data: data, });
+        });
+        let existsChecks = 30;
+        while (existsChecks > 0) {
+            let exists = await this.getInfo(fileName);
+            if (exists)
+                break;
+            await (0, batching_1.delay)(1000);
+            existsChecks--;
+        }
+        if (existsChecks === 0) {
+            let exists = await this.getInfo(fileName);
+            console.warn(`File ${fileName}/${f} was uploaded, but could not be found afterwards. Hopefully it was just deleted, very quickly? If backblaze is taking too long for files to propagate, then we might run into issues with the database atomicity.`);
+        }
+    }
+    async del(fileName) {
+        this.log(`backblaze delete ${fileName}`);
+        try {
+            await this.apiRetryLogic(`hideFile ${fileName}`, async (api) => {
+                await api.hideFile({ bucketId: this.bucketId, fileName: fileName });
+            });
+        }
+        catch (e) {
+            this.log(`backblaze error in hide, possibly already hidden ${fileName}\n${e.stack}`);
+        }
+        // NOTE: Deletion SEEMS to work. This DOES break if we delete a file which keeps being recreated,
+        //  ex, the heartbeat.
+        // let existsChecks = 10;
+        // while (existsChecks > 0) {
+        //     let exists = await this.getInfo(fileName);
+        //     if (!exists) break;
+        //     await delay(1000);
+        //     existsChecks--;
+        // }
+        // if (existsChecks === 0) {
+        //     let exists = await this.getInfo(fileName);
+        //     devDebugbreak();
+        //     console.warn(`File ${fileName} was deleted, but was still found afterwards`);
+        //     exists = await this.getInfo(fileName);
+        // }
+    }
+    async setLargeFile(config) {
+        let onError = [];
+        let time = Date.now();
+        try {
+            let { path } = config;
+            // Backblaze requires 5MB chunks. But, larger is more efficient for us.
+            const MIN_CHUNK_SIZE = 32 * 1024 * 1024;
+            let dataQueue = [];
+            async function getNextData() {
+                if (dataQueue.length)
+                    return dataQueue.shift();
+                // Get buffers until we get 5MB, OR, end. Backblaze requires this for large files.
+                let totalBytes = 0;
+                let buffers = [];
+                while (totalBytes < MIN_CHUNK_SIZE) {
+                    let data = await config.getNextData();
+                    if (!data)
+                        break;
+                    totalBytes += data.length;
+                    buffers.push(data);
+                }
+                if (!buffers.length)
+                    return undefined;
+                return Buffer.concat(buffers);
+            }
+            let fileName = path;
+            let data = await getNextData();
+            if (!(data === null || data === void 0 ? void 0 : data.length))
+                return;
+            // Backblaze disallows overly small files
+            if (data.length < MIN_CHUNK_SIZE) {
+                return await this.set(fileName, data);
+            }
+            // Backblaze disallows less than 2 chunks
+            let secondData = await getNextData();
+            if (!(secondData === null || secondData === void 0 ? void 0 : secondData.length)) {
+                return await this.set(fileName, data);
+            }
+            // ALSO, if there are two chunks, but one is too small, combine it. This helps allow us never
+            //  send small chunks.
+            if (secondData.length < MIN_CHUNK_SIZE) {
+                return await this.set(fileName, Buffer.concat([data, secondData]));
+            }
+            this.log(`Uploading large file ${config.path}`);
+            dataQueue.unshift(data, secondData);
+            let uploadInfo = await this.apiRetryLogic(`startLargeFile ${fileName}`, async (api) => {
+                return await api.startLargeFile({
+                    bucketId: this.bucketId,
+                    fileName: fileName,
+                    contentType: "b2/x-auto",
+                    fileInfo: {},
+                });
+            });
+            onError.push(async () => {
+                await this.apiRetryLogic(`cancelLargeFile ${fileName}`, async (api) => {
+                    await api.cancelLargeFile({ fileId: uploadInfo.fileId });
+                });
+            });
+            const LOG_INTERVAL = misc_1.timeInMinute;
+            let nextLogTime = Date.now() + LOG_INTERVAL;
+            let partNumber = 1;
+            let partSha1Array = [];
+            let totalBytes = 0;
+            while (true) {
+                data = await getNextData();
+                if (!data)
+                    break;
+                // So... if the next chunk is the last one, combine it with the current one. This
+                //  prevents ANY uploads from being < the threshold, as apparently the "last part"
+                //  check in backblaze fails when we have to retry an upload (due to "no tomes available").
+                //  Well it can't fail if even the last part is > 5MB, now can it!
+                // BUT, only if this isn't the first chunk, otherwise we might try to send
+                //  a single chunk, which we can't do.
+                if (partSha1Array.length > 0) {
+                    let maybeLastData = await getNextData();
+                    if (maybeLastData) {
+                        if (maybeLastData.length < MIN_CHUNK_SIZE) {
+                            // It's the last one, so consume it now
+                            data = Buffer.concat([data, maybeLastData]);
+                        }
+                        else {
+                            // It's not the last one. Put it back, in case the one AFTER is the last
+                            //  one, in which case we need to merge maybeLastData with the next next data.
+                            dataQueue.unshift(maybeLastData);
+                        }
+                    }
+                }
+                let sha1 = require("crypto").createHash("sha1");
+                sha1.update(data);
+                let sha1Hex = sha1.digest("hex");
+                partSha1Array.push(sha1Hex);
+                await this.apiRetryLogic(`uploadPart#${partNumber} ${fileName}`, async (api) => {
+                    if (!data)
+                        throw new Error("Impossible, data is undefined");
+                    let timeStr = (0, format_1.formatTime)(Date.now() - time);
+                    let rateStr = (0, format_1.formatNumber)(totalBytes / (Date.now() - time) * 1000) + "B/s";
+                    this.log(`Uploading large file part ${partNumber}, uploaded ${(0, logColors_1.blue)((0, format_1.formatNumber)(totalBytes) + "B")} in ${(0, logColors_1.blue)(timeStr)} (${(0, logColors_1.blue)(rateStr)}). ${config.path}`);
+                    totalBytes += data.length;
+                    await api.uploadPart({
+                        fileId: uploadInfo.fileId,
+                        partNumber: partNumber,
+                        data: data,
+                        sha1: sha1Hex,
+                    });
+                });
+                partNumber++;
+                if (Date.now() > nextLogTime) {
+                    nextLogTime = Date.now() + LOG_INTERVAL;
+                    let timeStr = (0, format_1.formatTime)(Date.now() - time);
+                    let rateStr = (0, format_1.formatNumber)(totalBytes / (Date.now() - time) * 1000) + "B/s";
+                    console.log(`Still uploading large file at ${Date.now()}. Uploaded ${(0, format_1.formatNumber)(totalBytes)}B in ${timeStr} (${rateStr}). ${config.path}`);
+                }
+            }
+            this.log(`Finished uploading large file uploaded ${(0, logColors_1.green)((0, format_1.formatNumber)(totalBytes))}B`);
+            await this.apiRetryLogic(`finishLargeFile ${fileName}`, async (api) => {
+                await api.finishLargeFile({
+                    fileId: uploadInfo.fileId,
+                    partSha1Array: partSha1Array,
+                });
+            });
+        }
+        catch (e) {
+            for (let c of onError) {
+                try {
+                    await c();
+                }
+                catch (e) {
+                    console.error(`Error during error clean. Ignoring, we will rethrow the original error, path ${config.path}`, e);
+                }
+            }
+            throw new Error(`Error in setLargeFile for ${config.path}: ${e.stack}`);
+        }
+    }
+    async getInfo(fileName) {
+        return await this.apiRetryLogic(`getInfo ${fileName}`, async (api) => {
+            try {
+                // NOTE: Apparently, there's no other way to do this, as the file name does not equal the file ID, and get file info requires the file ID.
+                let info = await api.listFileNames({ bucketId: this.bucketId, prefix: fileName, maxFileCount: 10 });
+                let file = info.files.find(x => x.fileName === fileName && x.action === "upload");
+                if (!file) {
+                    this.log(`Backblaze file not exists ${fileName}`);
+                    return undefined;
+                }
+                this.log(`Backblaze file exists ${fileName}`);
+                return {
+                    writeTime: file.uploadTimestamp,
+                    size: file.contentLength,
+                };
+            }
+            catch (e) {
+                if (e.stack.includes(`file_not_found`)) {
+                    this.log(`Backblaze file not exists ${fileName}`);
+                    return undefined;
+                }
+                throw e;
+            }
+        });
+    }
+    // For example findFileNames("ips/")
+    async find(prefix, config) {
+        let result = await this.findInfo(prefix, config);
+        return result.map(x => x.path);
+    }
+    async findInfo(prefix, config) {
+        return await this.apiRetryLogic(`findInfo ${prefix}`, async (api) => {
+            if (!(config === null || config === void 0 ? void 0 : config.shallow) && (config === null || config === void 0 ? void 0 : config.type) === "folders") {
+                let allFiles = await this.findInfo(prefix);
+                let allFolders = new Map();
+                for (let { path, createTime, size } of allFiles) {
+                    let folder = path.split("/").slice(0, -1).join("/");
+                    if (!folder)
+                        continue;
+                    allFolders.set(folder, { path: folder, createTime, size });
+                }
+                return Array.from(allFolders.values());
+            }
+            let files = new Map();
+            let startFileName = "";
+            while (true) {
+                let result = await api.listFileNames({
+                    bucketId: this.bucketId,
+                    prefix: prefix,
+                    startFileName,
+                    maxFileCount: 1000,
+                    delimiter: (config === null || config === void 0 ? void 0 : config.shallow) ? "/" : undefined,
+                });
+                for (let file of result.files) {
+                    if (file.action === "upload" && (config === null || config === void 0 ? void 0 : config.type) !== "folders") {
+                        files.set(file.fileName, { path: file.fileName, createTime: file.uploadTimestamp, size: file.contentLength });
+                    }
+                    else if (file.action === "folder" && (config === null || config === void 0 ? void 0 : config.type) === "folders") {
+                        let folder = file.fileName;
+                        if (folder.endsWith("/")) {
+                            folder = folder.slice(0, -1);
+                        }
+                        files.set(folder, { path: folder, createTime: file.uploadTimestamp, size: file.contentLength });
+                    }
+                }
+                startFileName = result.nextFileName;
+                if (!startFileName)
+                    break;
+            }
+            return Array.from(files.values());
+        });
+    }
+    async assertPathValid(path) {
+        let bytes = Buffer.from(path, "utf8");
+        if (bytes.length > 1000) {
+            throw new Error(`Path too long: ${path.length} characters > 1000 characters. Path: ${path}`);
+        }
+    }
+    async move(config) {
+        let { path, target, targetPath } = config;
+        // A self move should NOOP (and definitely not copy, and then delete itself!)
+        if (target === this && path === targetPath) {
+            this.log(`Backblaze move path to itself. Skipping move, as there is no work to do. ${path}`);
+            return;
+        }
+        if (target instanceof ArchivesBackblaze) {
+            let targetBucketId = target.bucketId;
+            if (targetBucketId === this.bucketId && path === targetPath)
+                return;
+            await this.apiRetryLogic(`move ${path} -> ${targetPath}`, async (api) => {
+                // Ugh... listing the file name sucks, but... I guess it's still better than
+                //  downloading and re-uploading the entire file.
+                let info = await api.listFileNames({ bucketId: this.bucketId, prefix: path, maxFileCount: 10 });
+                let file = info.files.find(x => x.fileName === path);
+                if (!file)
+                    throw new Error(`File not found to move: ${path}`);
+                await api.copyFile({
+                    sourceFileId: file.fileId,
+                    fileName: targetPath,
+                    destinationBucketId: targetBucketId,
+                });
+            });
+        }
+        else {
+            let data = await this.get(path);
+            if (!data)
+                throw new Error(`File not found to move: ${path}`);
+            await target.set(targetPath, data);
+        }
+        if (!config.copyInstead) {
+            let exists = await this.getInfo(targetPath);
+            if (!exists) {
+                console.error(`File not found after move. Leaving BOTH files. ${targetPath} was not found. Being moved from ${path}`);
+            }
+            else {
+                await this.del(path);
+            }
+        }
+    }
+    async copy(config) {
+        return this.move({ ...config, copyInstead: true });
+    }
+    async getURL(path) {
+        return await this.apiRetryLogic(`getURL ${path}`, async (api) => {
+            if (path.startsWith("/")) {
+                path = path.slice(1);
+            }
+            return await api.getDownloadURL("file/" + this.bucketName + "/" + path);
+        });
+    }
+    async getDownloadAuthorization(config) {
+        var _a;
+        return await this.apiRetryLogic(`getDownloadAuthorization ${(_a = config.fileNamePrefix) !== null && _a !== void 0 ? _a : ""}`, async (api) => {
+            var _a;
+            return await api.getDownloadAuthorization({
+                bucketId: this.bucketId,
+                fileNamePrefix: (_a = config.fileNamePrefix) !== null && _a !== void 0 ? _a : "",
+                ...config,
+            });
+        });
+    }
+}
+exports.ArchivesBackblaze = ArchivesBackblaze;
+/*
+Names should be a UTF-8 string up to 1024 bytes with the following exceptions:
+    Character codes below 32 are not allowed.
+    DEL characters (127) are not allowed.
+    Backslashes are not allowed.
+    File names cannot start with /, end with /, or contain //.
+*/
+exports.getArchivesBackblaze = (0, caching_1.cache)((domain) => {
+    return new ArchivesBackblaze({ bucketName: domain });
+});
+exports.getArchivesBackblazePrivateImmutable = (0, caching_1.cache)((domain) => {
+    return new ArchivesBackblaze({
+        bucketName: domain + "-private-immutable",
+        immutable: true
+    });
+});
+exports.getArchivesBackblazePublicImmutable = (0, caching_1.cache)((domain) => {
+    return new ArchivesBackblaze({
+        bucketName: domain + "-public-immutable",
+        public: true,
+        immutable: true,
+        allowedOrigins: [`https://${domain}`, `https://127-0-0-1.${domain}:7007`],
+    });
+});
+// NOTE: Cache by a minute. This might be a bad idea, but... usually whole reason for public is
+//  for cloudflare caching (as otherwise we can just access it through a server), or for large files
+//  (which should be cached anyways, and probably even use immutable caching).
+exports.getArchivesBackblazePublic = (0, caching_1.cache)((domain) => {
+    return new ArchivesBackblaze({
+        bucketName: domain + "-public",
+        public: true,
+        cacheTime: misc_1.timeInMinute,
+        allowedOrigins: [`https://${domain}`, `https://127-0-0-1.${domain}:7007`],
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"backblaze.js","sourceRoot":"","sources":["backblaze.ts"],"names":[],"mappings":"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","sourcesContent":["import { cache, lazy } from \"socket-function/src/caching\";\nimport fs from \"fs\";\nimport os from \"os\";\nimport { isNode, sort, timeInHour, timeInMinute } from \"socket-function/src/misc\";\nimport { delay } from \"socket-function/src/batching\";\nimport { formatNumber, formatTime } from \"socket-function/src/formatting/format\";\nimport { blue, green, magenta } from \"socket-function/src/formatting/logColors\";\nimport debugbreak from \"debugbreak\";\nimport dns from \"dns\";\nimport { getSecret } from \"../misc/getSecret\";\nimport { httpsRequest } from \"socket-function/src/https\";\nimport { IArchives, ArchivesConfig, assertValidLastModified, IMMUTABLE_CACHE_TIME } from \"./IArchives\";\n\ntype BackblazeCreds = {\n    applicationKeyId: string;\n    applicationKey: string;\n};\n\nlet backblazeCreds = lazy(async (): Promise<BackblazeCreds> => {\n    let keyId = await getSecret(\"backblaze.json.applicationKeyId\");\n    let key = await getSecret(\"backblaze.json.applicationKey\");\n    return {\n        applicationKeyId: keyId,\n        applicationKey: key,\n    };\n});\nconst getAPI = lazy(async () => {\n    let creds = await backblazeCreds();\n\n    // NOTE: On errors, our retry code resets this lazy, so we DO get new authorize when needed.\n    // TODO: Maybe we should get new authorization periodically at well?\n    let authorizeRaw = await httpsRequest(\"https://api.backblazeb2.com/b2api/v2/b2_authorize_account\", undefined, \"GET\", undefined, {\n        headers: {\n            Authorization: \"Basic \" + Buffer.from(creds.applicationKeyId + \":\" + creds.applicationKey).toString(\"base64\"),\n        }\n    });\n\n    let auth = JSON.parse(authorizeRaw.toString()) as {\n        accountId: string;\n        authorizationToken: string;\n        apiUrl: string;\n        downloadUrl: string;\n        allowed: {\n            bucketId: string;\n            bucketName: string;\n            capabilities: string[];\n            namePrefix: string;\n        }[];\n    };\n\n    function createB2Function<Arg, Result>(name: string, type: \"POST\" | \"GET\", noAccountId?: \"noAccountId\"): (arg: Arg) => Promise<Result> {\n        return async (arg: Arg) => {\n            if (!noAccountId) {\n                arg = { accountId: auth.accountId, ...arg };\n            }\n            try {\n                let url = auth.apiUrl + \"/b2api/v2/\" + name;\n                let result = await httpsRequest(url, Buffer.from(JSON.stringify(arg)), type, undefined, {\n                    headers: {\n                        Authorization: auth.authorizationToken,\n                    }\n                });\n                return JSON.parse(result.toString());\n            } catch (e: any) {\n                throw new Error(`Error in ${name}, arg ${JSON.stringify(arg).slice(0, 1000)}: ${e.stack}`);\n            }\n        };\n    }\n\n    const createBucket = createB2Function<{\n        bucketName: string;\n        bucketType: \"allPrivate\" | \"allPublic\";\n        lifecycleRules?: any[];\n        corsRules?: unknown[];\n        bucketInfo?: {\n            [key: string]: unknown;\n        };\n    }, {\n        accountId: string;\n        bucketId: string;\n        bucketName: string;\n        bucketType: \"allPrivate\" | \"allPublic\";\n        bucketInfo: {\n            lifecycleRules: any[];\n        };\n        corsRules: any[];\n        lifecycleRules: any[];\n        revision: number;\n    }>(\"b2_create_bucket\", \"POST\");\n\n    const updateBucket = createB2Function<{\n        accountId: string;\n        bucketId: string;\n        bucketType?: \"allPrivate\" | \"allPublic\";\n        lifecycleRules?: any[];\n        bucketInfo?: {\n            [key: string]: unknown;\n        };\n        corsRules?: unknown[];\n    }, {\n        accountId: string;\n        bucketId: string;\n        bucketName: string;\n        bucketType: \"allPrivate\" | \"allPublic\";\n        bucketInfo: {\n            lifecycleRules: any[];\n        };\n        corsRules: any[];\n        lifecycleRules: any[];\n        revision: number;\n    }>(\"b2_update_bucket\", \"POST\");\n\n    // https://www.backblaze.com/apidocs/b2-update-bucket\n    //  TODO: b2_update_bucket, so we can update CORS, etc\n\n    const listBuckets = createB2Function<{\n        bucketName?: string;\n    }, {\n        buckets: {\n            accountId: string;\n            bucketId: string;\n            bucketName: string;\n            bucketType: \"allPrivate\" | \"allPublic\";\n            bucketInfo: {\n                lifecycleRules: any[];\n            };\n            corsRules: any[];\n            lifecycleRules: any[];\n            revision: number;\n        }[];\n    }>(\"b2_list_buckets\", \"POST\");\n\n    function encodePath(path: string) {\n        // Preserve slashes, but encode everything else\n        path = path.split(\"/\").map(encodeURIComponent).join(\"/\");\n        if (path.startsWith(\"/\")) path = \"%2F\" + path.slice(1);\n        if (path.endsWith(\"/\")) path = path.slice(0, -1) + \"%2F\";\n        // NOTE: For some reason, this won't render in the web UI correctly. BUT, it'll\n        //  work get get/set and find\n        //  - ALSO, it seems to add duplicate files? This might also be a web UI thing. It\n        //      seems to work though.\n        while (path.includes(\"//\")) {\n            path = path.replaceAll(\"//\", \"/%2F\");\n        }\n        return path;\n    }\n\n    async function downloadFileByName(config: {\n        bucketName: string;\n        fileName: string;\n        range?: { start: number; end: number; };\n    }) {\n        let fileName = encodePath(config.fileName);\n\n        let result = await httpsRequest(auth.apiUrl + \"/file/\" + config.bucketName + \"/\" + fileName, Buffer.from(JSON.stringify({\n            accountId: auth.accountId,\n            responseType: \"arraybuffer\",\n        })), \"GET\", undefined, {\n            headers: Object.fromEntries(Object.entries({\n                Authorization: auth.authorizationToken,\n                \"Content-Type\": \"application/json\",\n                Range: config.range ? `bytes=${config.range.start}-${config.range.end - 1}` : undefined,\n            }).filter(x => x[1] !== undefined)),\n        });\n        return result;\n    }\n\n    // Oh... apparently, we can't reuse these? Huh...\n    const getUploadURL = (async (bucketId: string) => {\n        //setTimeout(() => getUploadURL.clear(bucketId), timeInHour * 1);\n        let getUploadUrlRaw = await httpsRequest(auth.apiUrl + \"/b2api/v2/b2_get_upload_url?bucketId=\" + bucketId, undefined, \"GET\", undefined, {\n            headers: {\n                Authorization: auth.authorizationToken,\n            }\n        });\n\n        return JSON.parse(getUploadUrlRaw.toString()) as {\n            bucketId: string;\n            uploadUrl: string;\n            authorizationToken: string;\n        };\n    });\n\n    async function uploadFile(config: {\n        bucketId: string;\n        fileName: string;\n        data: Buffer;\n    }) {\n        let getUploadUrl = await getUploadURL(config.bucketId);\n\n        await httpsRequest(getUploadUrl.uploadUrl, config.data, \"POST\", undefined, {\n            headers: {\n                Authorization: getUploadUrl.authorizationToken,\n                \"X-Bz-File-Name\": encodePath(config.fileName),\n                \"Content-Type\": \"b2/x-auto\",\n                \"X-Bz-Content-Sha1\": \"do_not_verify\",\n                \"Content-Length\": config.data.length + \"\",\n            }\n        });\n    }\n\n    const hideFile = createB2Function<{\n        bucketId: string;\n        fileName: string;\n    }, {}>(\"b2_hide_file\", \"POST\", \"noAccountId\");\n\n    const getFileInfo = createB2Function<{\n        bucketName: string;\n        fileId: string;\n    }, {\n        fileId: string;\n        fileName: string;\n        accountId: string;\n        bucketId: string;\n        contentLength: number;\n        contentSha1: string;\n        contentType: string;\n        fileInfo: {\n            src_last_modified_millis: number;\n        };\n        action: string;\n        uploadTimestamp: number;\n    }>(\"b2_get_file_info\", \"POST\", \"noAccountId\");\n\n    const listFileNames = createB2Function<{\n        bucketId: string;\n        prefix: string;\n        startFileName?: string;\n        maxFileCount?: number;\n        delimiter?: string;\n    }, {\n        files: {\n            fileId: string;\n            fileName: string;\n            accountId: string;\n            bucketId: string;\n            contentLength: number;\n            contentSha1: string;\n            contentType: string;\n            fileInfo: {\n                src_last_modified_millis: number;\n            };\n            action: string;\n            uploadTimestamp: number;\n        }[];\n        nextFileName: string;\n    }>(\"b2_list_file_names\", \"POST\", \"noAccountId\");\n\n    const copyFile = createB2Function<{\n        sourceFileId: string;\n        fileName: string;\n        destinationBucketId: string;\n    }, {}>(\"b2_copy_file\", \"POST\", \"noAccountId\");\n\n    const startLargeFile = createB2Function<{\n        bucketId: string;\n        fileName: string;\n        contentType: string;\n        fileInfo: { [key: string]: string };\n    }, {\n        fileId: string;\n        fileName: string;\n        accountId: string;\n        bucketId: string;\n        contentType: string;\n        fileInfo: any;\n        uploadTimestamp: number;\n    }>(\"b2_start_large_file\", \"POST\", \"noAccountId\");\n\n    // Apparently we can't reuse these?\n    const getUploadPartURL = (async (fileId: string) => {\n        let uploadPartRaw = await httpsRequest(auth.apiUrl + \"/b2api/v2/b2_get_upload_part_url?fileId=\" + fileId, undefined, \"GET\", undefined, {\n            headers: {\n                Authorization: auth.authorizationToken,\n            }\n        });\n        return JSON.parse(uploadPartRaw.toString()) as {\n            fileId: string;\n            partNumber: number;\n            uploadUrl: string;\n            authorizationToken: string;\n        };\n    });\n    async function uploadPart(config: {\n        fileId: string;\n        partNumber: number;\n        data: Buffer;\n        sha1: string;\n    }): Promise<{\n        fileId: string;\n        partNumber: number;\n        contentLength: number;\n        contentSha1: string;\n    }> {\n        let uploadPart = await getUploadPartURL(config.fileId);\n\n        let result = await httpsRequest(uploadPart.uploadUrl, config.data, \"POST\", undefined, {\n            headers: {\n                Authorization: uploadPart.authorizationToken,\n                \"X-Bz-Part-Number\": config.partNumber + \"\",\n                \"X-Bz-Content-Sha1\": config.sha1,\n                \"Content-Length\": config.data.length + \"\",\n\n            }\n        });\n        return JSON.parse(result.toString());\n    }\n\n    const finishLargeFile = createB2Function<{\n        fileId: string;\n        partSha1Array: string[];\n    }, {\n        fileId: string;\n        fileName: string;\n        accountId: string;\n        bucketId: string;\n        contentLength: number;\n        contentSha1: string;\n        contentType: string;\n        fileInfo: any;\n        uploadTimestamp: number;\n    }>(\"b2_finish_large_file\", \"POST\", \"noAccountId\");\n\n    const cancelLargeFile = createB2Function<{\n        fileId: string;\n    }, {}>(\"b2_cancel_large_file\", \"POST\", \"noAccountId\");\n\n    const getDownloadAuthorization = createB2Function<{\n        bucketId: string;\n        fileNamePrefix: string;\n        validDurationInSeconds: number;\n        b2ContentDisposition?: string;\n        b2ContentLanguage?: string;\n        b2Expires?: string;\n        b2CacheControl?: string;\n        b2ContentEncoding?: string;\n        b2ContentType?: string;\n    }, {\n        bucketId: string;\n        fileNamePrefix: string;\n        authorizationToken: string;\n    }>(\"b2_get_download_authorization\", \"POST\", \"noAccountId\");\n\n    async function getDownloadURL(path: string) {\n        if (!path.startsWith(\"/\")) {\n            path = \"/\" + path;\n        }\n        return auth.downloadUrl + path;\n    }\n\n\n    return {\n        createBucket,\n        updateBucket,\n        listBuckets,\n        downloadFileByName,\n        uploadFile,\n        hideFile,\n        getFileInfo,\n        listFileNames,\n        copyFile,\n        startLargeFile,\n        uploadPart,\n        finishLargeFile,\n        cancelLargeFile,\n        getDownloadAuthorization,\n        getDownloadURL,\n        apiUrl: auth.apiUrl,\n        allowed: auth.allowed,\n    };\n});\n\ntype B2Api = (typeof getAPI) extends () => Promise<infer T> ? T : never;\n\n\nexport class ArchivesBackblaze implements IArchives {\n    public constructor(private config: {\n        bucketName: string;\n        public?: boolean;\n        immutable?: boolean;\n        cacheTime?: number;\n        allowedOrigins?: string[];\n    }) {\n        // Get the api, to setup cors\n        void this.getBucketAPI();\n    }\n\n    private bucketName = this.config.bucketName.replaceAll(/[^\\w\\d]/g, \"-\");\n    private bucketId = \"\";\n\n    private logging = false;\n    public enableLogging() {\n        this.logging = true;\n    }\n    private log(text: string) {\n        if (!this.logging) return;\n        console.log(text);\n    }\n\n    public getDebugName() {\n        return \"backblaze/\" + this.config.bucketName;\n    }\n\n    private getBucketAPI = lazy(async () => {\n        let api = await getAPI();\n\n        let cacheTime = this.config.cacheTime ?? 0;\n        if (this.config.immutable) {\n            cacheTime = IMMUTABLE_CACHE_TIME;\n        }\n\n        // ALWAYS set access control, as we can make urls for private buckets with getDownloadAuthorization\n        let desiredCorsRules = [{\n            corsRuleName: \"allowAll\",\n            allowedOrigins: this.config.allowedOrigins ?? [\"https\"],\n            allowedOperations: [\"b2_download_file_by_id\", \"b2_download_file_by_name\"],\n            allowedHeaders: [\"range\"],\n            exposeHeaders: [\"x-bz-content-sha1\"],\n            maxAgeSeconds: cacheTime / 1000,\n        }];\n        let bucketInfo: Record<string, unknown> = {};\n        if (cacheTime) {\n            bucketInfo[\"cache-control\"] = `max-age=${cacheTime / 1000}`;\n        }\n\n\n        let exists = false;\n        let retries = 0;\n        while (true) {\n            try {\n                await api.createBucket({\n                    bucketName: this.bucketName,\n                    bucketType: this.config.public ? \"allPublic\" : \"allPrivate\",\n                    lifecycleRules: [{\n                        \"daysFromUploadingToHiding\": null,\n                        // Keep files for 7 days, which should be enough time to recover accidental hiding.\n                        \"daysFromHidingToDeleting\": 7,\n                        \"fileNamePrefix\": \"\"\n                    }],\n                    corsRules: desiredCorsRules,\n                    bucketInfo\n                });\n            } catch (e: any) {\n                if (!e.stack.includes(`\"duplicate_bucket_name\"`)) {\n                    if (retries < 3) {\n                        console.error(`Backblaze create bucket failed, retrying in 5s: ${e.stack}`);\n                        await delay(5000);\n                        retries++;\n                        continue;\n                    }\n                    throw e;\n                }\n                exists = true;\n            }\n            break;\n        }\n\n        let bucketList = await api.listBuckets({\n            bucketName: this.bucketName,\n        });\n        if (bucketList.buckets.length === 0) {\n            throw new Error(`Bucket name \"${this.bucketName}\" is being used by someone else. Bucket names have to be globally unique. Try a different name until you find a free one.`);\n        }\n        this.bucketId = bucketList.buckets[0].bucketId;\n\n        if (exists) {\n            let bucket = bucketList.buckets[0];\n            function normalize(obj: Record<string, unknown>) {\n                let kvps = Object.entries(obj);\n                sort(kvps, x => x[0]);\n                return Object.fromEntries(kvps);\n            }\n            function orderIndependentEqual(lhs: Record<string, unknown>, rhs: Record<string, unknown>) {\n                return JSON.stringify(normalize(lhs)) === JSON.stringify(normalize(rhs));\n            }\n            function orderIndependentEqualArray(lhs: unknown[], rhs: unknown[]) {\n                if (lhs.length !== rhs.length) return false;\n                for (let i = 0; i < lhs.length; i++) {\n                    if (!orderIndependentEqual(lhs[i] as Record<string, unknown>, rhs[i] as Record<string, unknown>)) return false;\n                }\n                return true;\n            }\n            if (\n                !orderIndependentEqualArray(bucket.corsRules, desiredCorsRules)\n                || !orderIndependentEqual(bucket.bucketInfo, bucketInfo)\n            ) {\n                console.log(magenta(`Updating CORS rules for ${this.bucketName}`), bucket.corsRules, desiredCorsRules);\n                await api.updateBucket({\n                    accountId: bucket.accountId,\n                    bucketId: bucket.bucketId,\n                    bucketType: bucket.bucketType,\n                    lifecycleRules: bucket.lifecycleRules,\n                    corsRules: desiredCorsRules,\n                    bucketInfo: bucketInfo,\n                });\n            }\n        }\n        return api;\n    });\n\n    private currentReset: Promise<void> | undefined;\n\n    // Keep track of when we last reset because of a 503\n    private last503Reset = 0;\n    // IMPORTANT! We must always CATCH AROUND the apiRetryLogic, NEVER inside of fnc. Otherwise we won't\n    //  be able to recreate the auth token.\n    //  `context` is a short label (verb + file path) included in every retry/error log so a stuck\n    //   silent-retry loop is identifiable from the logs.\n    private async apiRetryLogic<T>(\n        context: string,\n        fnc: (api: B2Api) => Promise<T>,\n        retries = 3\n    ): Promise<T> {\n        let api: B2Api | undefined;\n        try {\n            api = await this.getBucketAPI();\n            return await fnc(api);\n        } catch (err: any) {\n            if (retries <= 0) throw err;\n\n            // If it's a 503 and it's been a minute since we last reset, then Wait and reset.\n            if (\n                (err.stack.includes(`\"status\": 503`)\n                    || err.stack.includes(`\"service_unavailable\"`)\n                    || err.stack.includes(`\"internal_error\"`)\n                    || err.stack.includes(`ENOBUFS`)\n                ) && Date.now() - this.last503Reset > 60 * 1000) {\n                // Backblaze is so flaky that we're just going to warn here.\n                console.warn(`[${context}] Backblaze error, waiting and resetting: ${err.message}`);\n                this.log(`[${context}] Backblaze error, waiting and resetting: ${err.message}`);\n                this.currentReset = this.currentReset || (async () => {\n                    await delay(10 * 1000);\n                    // We check again in case, and in the very likely case that this is being run in parallel, we only want to reset once.\n                    if (Date.now() - this.last503Reset > 60 * 1000) {\n                        this.log(`[${context}] Resetting getAPI and getBucketAPI: ${err.message}`);\n                        this.last503Reset = Date.now();\n                        getAPI.reset();\n                        this.getBucketAPI.reset();\n                    }\n                })().finally(() => this.currentReset = undefined);\n                await this.currentReset;\n                return this.apiRetryLogic(context, fnc, retries - 1);\n            }\n\n            // If the error is that the authorization token is invalid, reset getBucketAPI and getAPI\n            // If the error is that the bucket isn't found, reset getBucketAPI\n            if (err.stack.includes(`\"expired_auth_token\"`)) {\n                this.log(`[${context}] Authorization token expired`);\n                getAPI.reset();\n                this.getBucketAPI.reset();\n                return this.apiRetryLogic(context, fnc, retries - 1);\n            }\n\n            if (\n                err.stack.includes(`no tomes available`)\n                || err.stack.includes(`ETIMEDOUT`)\n                || err.stack.includes(`socket hang up`)\n                // Eh... this might be bad, but... I think we just get random 400 errors. If this spams errors,\n                //  we can remove this line.\n                || err.stack.includes(`400 Bad Request`)\n                || err.stack.includes(`getaddrinfo ENOTFOUND`)\n                || err.stack.includes(`ECONNRESET`)\n                || err.stack.includes(`ECONNREFUSED`)\n                || err.stack.includes(`ENOBUFS`)\n            ) {\n                console.warn(`[${context}] Retrying in 5s: ${err.message}`);\n                this.log(`[${context}] ${err.message} retrying in 5s`);\n                await delay(5000);\n                return this.apiRetryLogic(context, fnc, retries - 1);\n            }\n\n            if (err.stack.includes(`getaddrinfo ENOTFOUND`)) {\n                if (api) {\n                    let urlObj = new URL(api.apiUrl);\n                    let hostname = urlObj.hostname;\n                    let lookupAddresses = await new Promise(resolve => {\n                        dns.lookup(hostname, (err, addresses) => {\n                            resolve(addresses);\n                        });\n                    });\n                    let resolveAddresses = await new Promise(resolve => {\n                        dns.resolve4(hostname, (err, addresses) => {\n                            resolve(addresses);\n                        });\n                    });\n                    console.error(`[${context}] getaddrinfo ENOTFOUND ${hostname}`, { lookupAddresses, resolveAddresses, apiUrl: api.apiUrl, fullError: err.stack });\n                }\n            }\n\n            throw err;\n        }\n    }\n\n    public async get(fileName: string, config?: { range?: { start: number; end: number; }; retryCount?: number }): Promise<Buffer | undefined> {\n        let downloading = true;\n        try {\n            let time = Date.now();\n            const downloadPoll = () => {\n                if (!downloading) return;\n                this.log(`Backblaze download in progress ${fileName}`);\n                setTimeout(downloadPoll, 5000);\n            };\n            setTimeout(downloadPoll, 5000);\n            let result = await this.apiRetryLogic(`get ${fileName}`, async (api) => {\n                let range = config?.range;\n                if (range) {\n                    let fileInfo = await this.getInfo(fileName);\n                    if (!fileInfo) throw new Error(`File ${fileName} not found`);\n                    let rangeStart = range.start;\n                    let rangeEnd = Math.min(range.end, fileInfo.size);\n                    // NOTE: I think if we request nothing, it confuses Backblaze and ends up giving us the entire file.\n                    if (rangeEnd <= rangeStart) return Buffer.alloc(0);\n                    let result = await api.downloadFileByName({\n                        bucketName: this.bucketName,\n                        fileName,\n                        range: { start: rangeStart, end: rangeEnd },\n                    });\n                    if (result.length !== rangeEnd - rangeStart) {\n                        console.error(`Backblaze range download returned the wrong number of bytes. Tried to get ${rangeStart}-${rangeEnd}, but received ${rangeStart}-${rangeStart + result.length}. For file: ${fileName}`);\n                    }\n                    return result;\n                }\n                return await api.downloadFileByName({\n                    bucketName: this.bucketName,\n                    fileName,\n                });\n            });\n            let timeStr = formatTime(Date.now() - time);\n            let rateStr = formatNumber(result.length / (Date.now() - time) * 1000) + \"B/s\";\n            this.log(`backblaze download (${formatNumber(result.length)}B${config?.range && `, ${formatNumber(config.range.start)} - ${formatNumber(config.range.end)}` || \"\"}) in ${timeStr} (${rateStr}, ${fileName})`);\n            return result;\n        } catch (e) {\n            this.log(`backblaze file does not exist ${fileName}`);\n            return undefined;\n        } finally {\n            downloading = false;\n        }\n    }\n    public async get2(fileName: string, config?: { range?: { start: number; end: number; } }): Promise<{ data: Buffer; writeTime: number; size: number } | undefined> {\n        // B2 downloads don't return the upload time, so this takes a second API call\n        let [data, info] = await Promise.all([this.get(fileName, config), this.getInfo(fileName)]);\n        if (!data || !info) return undefined;\n        return { data, writeTime: info.writeTime, size: info.size };\n    }\n    public async getConfig(): Promise<ArchivesConfig> {\n        return {};\n    }\n    public async hasWriteAccess(): Promise<boolean> {\n        try {\n            let api = await getAPI();\n            // B2 v2 documents allowed as a single object; our type says a list - handle both\n            let allowedRaw = api.allowed as unknown;\n            let allowedList = (Array.isArray(allowedRaw) && allowedRaw || [allowedRaw]) as typeof api.allowed;\n            return allowedList.some(allowed =>\n                allowed.capabilities.includes(\"writeFiles\")\n                && (!allowed.bucketName || allowed.bucketName === this.bucketName)\n            );\n        } catch (e) {\n            // No / invalid credentials\n            this.log(`backblaze hasWriteAccess check failed: ${(e as Error).stack ?? e}`);\n            return false;\n        }\n    }\n    public async set(fileName: string, data: Buffer, config?: { lastModified?: number }): Promise<void> {\n        if (config?.lastModified) {\n            assertValidLastModified(config.lastModified);\n            let existing = await this.getInfo(fileName);\n            // An older write never overwrites a newer one (see IArchives.set). B2 stamps its own\n            // upload time, so the exact lastModified is not preserved on the stored file.\n            if (existing && config.lastModified < existing.writeTime) return;\n        }\n        this.log(`backblaze upload (${formatNumber(data.length)}B) ${fileName}`);\n        let f = fileName;\n        await this.apiRetryLogic(`uploadFile ${fileName}`, async (api) => {\n            await api.uploadFile({ bucketId: this.bucketId, fileName, data: data, });\n        });\n        let existsChecks = 30;\n        while (existsChecks > 0) {\n            let exists = await this.getInfo(fileName);\n            if (exists) break;\n            await delay(1000);\n            existsChecks--;\n        }\n        if (existsChecks === 0) {\n            let exists = await this.getInfo(fileName);\n            console.warn(`File ${fileName}/${f} was uploaded, but could not be found afterwards. Hopefully it was just deleted, very quickly? If backblaze is taking too long for files to propagate, then we might run into issues with the database atomicity.`);\n        }\n\n    }\n    public async del(fileName: string): Promise<void> {\n        this.log(`backblaze delete ${fileName}`);\n        try {\n            await this.apiRetryLogic(`hideFile ${fileName}`, async (api) => {\n                await api.hideFile({ bucketId: this.bucketId, fileName: fileName });\n            });\n        } catch (e: any) {\n            this.log(`backblaze error in hide, possibly already hidden ${fileName}\\n${e.stack}`);\n        }\n\n        // NOTE: Deletion SEEMS to work. This DOES break if we delete a file which keeps being recreated,\n        //  ex, the heartbeat.\n        // let existsChecks = 10;\n        // while (existsChecks > 0) {\n        //     let exists = await this.getInfo(fileName);\n        //     if (!exists) break;\n        //     await delay(1000);\n        //     existsChecks--;\n        // }\n        // if (existsChecks === 0) {\n        //     let exists = await this.getInfo(fileName);\n        //     devDebugbreak();\n        //     console.warn(`File ${fileName} was deleted, but was still found afterwards`);\n        //     exists = await this.getInfo(fileName);\n        // }\n    }\n\n    public async setLargeFile(config: { path: string; getNextData(): Promise<Buffer | undefined>; }): Promise<void> {\n\n        let onError: (() => Promise<void>)[] = [];\n        let time = Date.now();\n        try {\n            let { path } = config;\n            // Backblaze requires 5MB chunks. But, larger is more efficient for us.\n            const MIN_CHUNK_SIZE = 32 * 1024 * 1024;\n            let dataQueue: Buffer[] = [];\n            async function getNextData(): Promise<Buffer | undefined> {\n                if (dataQueue.length) return dataQueue.shift();\n                // Get buffers until we get 5MB, OR, end. Backblaze requires this for large files.\n                let totalBytes = 0;\n                let buffers: Buffer[] = [];\n                while (totalBytes < MIN_CHUNK_SIZE) {\n                    let data = await config.getNextData();\n                    if (!data) break;\n                    totalBytes += data.length;\n                    buffers.push(data);\n                }\n                if (!buffers.length) return undefined;\n                return Buffer.concat(buffers);\n            }\n\n            let fileName = path;\n            let data = await getNextData();\n            if (!data?.length) return;\n            // Backblaze disallows overly small files\n            if (data.length < MIN_CHUNK_SIZE) {\n                return await this.set(fileName, data);\n            }\n            // Backblaze disallows less than 2 chunks\n            let secondData = await getNextData();\n            if (!secondData?.length) {\n                return await this.set(fileName, data);\n            }\n            // ALSO, if there are two chunks, but one is too small, combine it. This helps allow us never\n            //  send small chunks.\n            if (secondData.length < MIN_CHUNK_SIZE) {\n                return await this.set(fileName, Buffer.concat([data, secondData]));\n            }\n            this.log(`Uploading large file ${config.path}`);\n            dataQueue.unshift(data, secondData);\n\n\n            let uploadInfo = await this.apiRetryLogic(`startLargeFile ${fileName}`, async (api) => {\n                return await api.startLargeFile({\n                    bucketId: this.bucketId,\n                    fileName: fileName,\n                    contentType: \"b2/x-auto\",\n                    fileInfo: {},\n                });\n            });\n            onError.push(async () => {\n                await this.apiRetryLogic(`cancelLargeFile ${fileName}`, async (api) => {\n                    await api.cancelLargeFile({ fileId: uploadInfo.fileId });\n                });\n            });\n\n            const LOG_INTERVAL = timeInMinute;\n            let nextLogTime = Date.now() + LOG_INTERVAL;\n\n            let partNumber = 1;\n            let partSha1Array: string[] = [];\n            let totalBytes = 0;\n            while (true) {\n                data = await getNextData();\n                if (!data) break;\n                // So... if the next chunk is the last one, combine it with the current one. This\n                //  prevents ANY uploads from being < the threshold, as apparently the \"last part\"\n                //  check in backblaze fails when we have to retry an upload (due to \"no tomes available\").\n                //  Well it can't fail if even the last part is > 5MB, now can it!\n                // BUT, only if this isn't the first chunk, otherwise we might try to send\n                //  a single chunk, which we can't do.\n                if (partSha1Array.length > 0) {\n                    let maybeLastData = await getNextData();\n                    if (maybeLastData) {\n                        if (maybeLastData.length < MIN_CHUNK_SIZE) {\n                            // It's the last one, so consume it now\n                            data = Buffer.concat([data, maybeLastData]);\n                        } else {\n                            // It's not the last one. Put it back, in case the one AFTER is the last\n                            //  one, in which case we need to merge maybeLastData with the next next data.\n                            dataQueue.unshift(maybeLastData);\n                        }\n                    }\n                }\n                let sha1 = require(\"crypto\").createHash(\"sha1\");\n                sha1.update(data);\n                let sha1Hex = sha1.digest(\"hex\");\n                partSha1Array.push(sha1Hex);\n                await this.apiRetryLogic(`uploadPart#${partNumber} ${fileName}`, async (api) => {\n                    if (!data) throw new Error(\"Impossible, data is undefined\");\n\n                    let timeStr = formatTime(Date.now() - time);\n                    let rateStr = formatNumber(totalBytes / (Date.now() - time) * 1000) + \"B/s\";\n                    this.log(`Uploading large file part ${partNumber}, uploaded ${blue(formatNumber(totalBytes) + \"B\")} in ${blue(timeStr)} (${blue(rateStr)}). ${config.path}`);\n                    totalBytes += data.length;\n\n                    await api.uploadPart({\n                        fileId: uploadInfo.fileId,\n                        partNumber: partNumber,\n                        data: data,\n                        sha1: sha1Hex,\n                    });\n                });\n                partNumber++;\n\n                if (Date.now() > nextLogTime) {\n                    nextLogTime = Date.now() + LOG_INTERVAL;\n                    let timeStr = formatTime(Date.now() - time);\n                    let rateStr = formatNumber(totalBytes / (Date.now() - time) * 1000) + \"B/s\";\n                    console.log(`Still uploading large file at ${Date.now()}. Uploaded ${formatNumber(totalBytes)}B in ${timeStr} (${rateStr}). ${config.path}`);\n                }\n            }\n            this.log(`Finished uploading large file uploaded ${green(formatNumber(totalBytes))}B`);\n\n            await this.apiRetryLogic(`finishLargeFile ${fileName}`, async (api) => {\n                await api.finishLargeFile({\n                    fileId: uploadInfo.fileId,\n                    partSha1Array: partSha1Array,\n                });\n            });\n        } catch (e: any) {\n            for (let c of onError) {\n                try {\n                    await c();\n                } catch (e) {\n                    console.error(`Error during error clean. Ignoring, we will rethrow the original error, path ${config.path}`, e);\n                }\n            }\n\n            throw new Error(`Error in setLargeFile for ${config.path}: ${e.stack}`);\n        }\n    }\n\n    public async getInfo(fileName: string): Promise<{ writeTime: number; size: number; } | undefined> {\n        return await this.apiRetryLogic(`getInfo ${fileName}`, async (api) => {\n            try {\n                // NOTE: Apparently, there's no other way to do this, as the file name does not equal the file ID, and get file info requires the file ID.\n                let info = await api.listFileNames({ bucketId: this.bucketId, prefix: fileName, maxFileCount: 10 });\n                let file = info.files.find(x => x.fileName === fileName && x.action === \"upload\");\n                if (!file) {\n                    this.log(`Backblaze file not exists ${fileName}`);\n                    return undefined;\n                }\n                this.log(`Backblaze file exists ${fileName}`);\n                return {\n                    writeTime: file.uploadTimestamp,\n                    size: file.contentLength,\n                };\n            } catch (e: any) {\n                if (e.stack.includes(`file_not_found`)) {\n                    this.log(`Backblaze file not exists ${fileName}`);\n                    return undefined;\n                }\n                throw e;\n            }\n        });\n    }\n\n    // For example findFileNames(\"ips/\")\n    public async find(prefix: string, config?: { shallow?: boolean; type: \"files\" | \"folders\" }): Promise<string[]> {\n        let result = await this.findInfo(prefix, config);\n        return result.map(x => x.path);\n    }\n    public async findInfo(prefix: string, config?: { shallow?: boolean; type: \"files\" | \"folders\" }): Promise<{ path: string; createTime: number; size: number; }[]> {\n        return await this.apiRetryLogic(`findInfo ${prefix}`, async (api) => {\n            if (!config?.shallow && config?.type === \"folders\") {\n                let allFiles = await this.findInfo(prefix);\n                let allFolders = new Map<string, { path: string; createTime: number; size: number }>();\n                for (let { path, createTime, size } of allFiles) {\n                    let folder = path.split(\"/\").slice(0, -1).join(\"/\");\n                    if (!folder) continue;\n                    allFolders.set(folder, { path: folder, createTime, size });\n                }\n                return Array.from(allFolders.values());\n            }\n            let files = new Map<string, { path: string; createTime: number; size: number; }>();\n            let startFileName = \"\";\n            while (true) {\n                let result = await api.listFileNames({\n                    bucketId: this.bucketId,\n                    prefix: prefix,\n                    startFileName,\n                    maxFileCount: 1000,\n                    delimiter: config?.shallow ? \"/\" : undefined,\n                });\n                for (let file of result.files) {\n                    if (file.action === \"upload\" && config?.type !== \"folders\") {\n                        files.set(file.fileName, { path: file.fileName, createTime: file.uploadTimestamp, size: file.contentLength });\n                    } else if (file.action === \"folder\" && config?.type === \"folders\") {\n                        let folder = file.fileName;\n                        if (folder.endsWith(\"/\")) {\n                            folder = folder.slice(0, -1);\n                        }\n                        files.set(folder, { path: folder, createTime: file.uploadTimestamp, size: file.contentLength });\n                    }\n\n                }\n                startFileName = result.nextFileName;\n                if (!startFileName) break;\n            }\n            return Array.from(files.values());\n        });\n    }\n\n    public async assertPathValid(path: string) {\n        let bytes = Buffer.from(path, \"utf8\");\n        if (bytes.length > 1000) {\n            throw new Error(`Path too long: ${path.length} characters > 1000 characters. Path: ${path}`);\n        }\n    }\n\n    public async move(config: {\n        path: string;\n        target: IArchives;\n        targetPath: string;\n        copyInstead?: boolean;\n    }) {\n        let { path, target, targetPath } = config;\n        // A self move should NOOP (and definitely not copy, and then delete itself!)\n        if (target === this && path === targetPath) {\n            this.log(`Backblaze move path to itself. Skipping move, as there is no work to do. ${path}`);\n            return;\n        }\n        if (target instanceof ArchivesBackblaze) {\n            let targetBucketId = target.bucketId;\n            if (targetBucketId === this.bucketId && path === targetPath) return;\n            await this.apiRetryLogic(`move ${path} -> ${targetPath}`, async (api) => {\n                // Ugh... listing the file name sucks, but... I guess it's still better than\n                //  downloading and re-uploading the entire file.\n                let info = await api.listFileNames({ bucketId: this.bucketId, prefix: path, maxFileCount: 10 });\n                let file = info.files.find(x => x.fileName === path);\n                if (!file) throw new Error(`File not found to move: ${path}`);\n                await api.copyFile({\n                    sourceFileId: file.fileId,\n                    fileName: targetPath,\n                    destinationBucketId: targetBucketId,\n                });\n            });\n        } else {\n            let data = await this.get(path);\n            if (!data) throw new Error(`File not found to move: ${path}`);\n            await target.set(targetPath, data);\n        }\n\n        if (!config.copyInstead) {\n            let exists = await this.getInfo(targetPath);\n            if (!exists) {\n                console.error(`File not found after move. Leaving BOTH files. ${targetPath} was not found. Being moved from ${path}`);\n            } else {\n                await this.del(path);\n            }\n        }\n    }\n\n    public async copy(config: {\n        path: string;\n        target: IArchives;\n        targetPath: string;\n    }): Promise<void> {\n        return this.move({ ...config, copyInstead: true });\n    }\n\n    public async getURL(path: string) {\n        return await this.apiRetryLogic(`getURL ${path}`, async (api) => {\n            if (path.startsWith(\"/\")) {\n                path = path.slice(1);\n            }\n            return await api.getDownloadURL(\"file/\" + this.bucketName + \"/\" + path);\n        });\n    }\n\n    public async getDownloadAuthorization(config: {\n        fileNamePrefix?: string;\n        validDurationInSeconds: number;\n        b2ContentDisposition?: string;\n        b2ContentLanguage?: string;\n        b2Expires?: string;\n        b2CacheControl?: string;\n        b2ContentEncoding?: string;\n        b2ContentType?: string;\n    }): Promise<{\n        bucketId: string;\n        fileNamePrefix: string;\n        authorizationToken: string;\n    }> {\n        return await this.apiRetryLogic(`getDownloadAuthorization ${config.fileNamePrefix ?? \"\"}`, async (api) => {\n            return await api.getDownloadAuthorization({\n                bucketId: this.bucketId,\n                fileNamePrefix: config.fileNamePrefix ?? \"\",\n                ...config,\n            });\n        });\n    }\n}\n\n/*\nNames should be a UTF-8 string up to 1024 bytes with the following exceptions:\n    Character codes below 32 are not allowed.\n    DEL characters (127) are not allowed.\n    Backslashes are not allowed.\n    File names cannot start with /, end with /, or contain //.\n*/\n\n\nexport const getArchivesBackblaze = cache((domain: string) => {\n    return new ArchivesBackblaze({ bucketName: domain });\n});\nexport const getArchivesBackblazePrivateImmutable = cache((domain: string) => {\n    return new ArchivesBackblaze({\n        bucketName: domain + \"-private-immutable\",\n        immutable: true\n    });\n});\nexport const getArchivesBackblazePublicImmutable = cache((domain: string) => {\n    return new ArchivesBackblaze({\n        bucketName: domain + \"-public-immutable\",\n        public: true,\n        immutable: true,\n        allowedOrigins: [`https://${domain}`, `https://127-0-0-1.${domain}:7007`],\n    });\n});\n\n// NOTE: Cache by a minute. This might be a bad idea, but... usually whole reason for public is\n//  for cloudflare caching (as otherwise we can just access it through a server), or for large files\n//  (which should be cached anyways, and probably even use immutable caching).\nexport const getArchivesBackblazePublic = cache((domain: string) => {\n    return new ArchivesBackblaze({\n        bucketName: domain + \"-public\",\n        public: true,\n        cacheTime: timeInMinute,\n        allowedOrigins: [`https://${domain}`, `https://127-0-0-1.${domain}:7007`],\n    });\n});"]}
+ /* _JS_SOURCE_HASH = "3e97e23ad6f49500641f2b4f9e5b6d839e15c53a0f7ebecd2222f65b2bc61eae"; */