sliftutils 1.7.10 → 1.7.11

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

@@ -0,0 +1,518 @@
+"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.getLocalArchives = exports.deleteBucketFile = exports.writeBucketFile = exports.assertMutable = exports.getLoadedBucket = exports.setTrustedMachines = exports.getRequests = exports.getTrust = exports.assertWritesAllowed = exports.getWritesRejectedReason = exports.setWritesRejectedReason = exports.getStorageServerConfigOptional = exports.getStorageServerConfig = exports.setStorageServerConfig = void 0;
+const path_1 = __importDefault(require("path"));
+const FileFolderAPI_1 = require("../FileFolderAPI");
+const TransactionStorage_1 = require("../TransactionStorage");
+const JSONStorage_1 = require("../JSONStorage");
+const ArchivesDisk_1 = require("../ArchivesDisk");
+const blobStore_1 = require("./blobStore");
+const IArchives_1 = require("../IArchives");
+const remoteConfig_1 = require("./remoteConfig");
+const createArchives_1 = require("./createArchives");
+const cliArgs_1 = require("./cliArgs");
+let config;
+function setStorageServerConfig(value) {
+    config = value;
+}
+exports.setStorageServerConfig = setStorageServerConfig;
+function getStorageServerConfig() {
+    if (!config) {
+        throw new Error(`Storage server is not initialized (this API only works on the storage server)`);
+    }
+    return config;
+}
+exports.getStorageServerConfig = getStorageServerConfig;
+// For self-detection: code that CAN run outside the storage server (createArchives) uses this to
+// check "is this URL our own process?" without throwing.
+function getStorageServerConfigOptional() {
+    return config;
+}
+exports.getStorageServerConfigOptional = getStorageServerConfigOptional;
+// When set, all write-path operations (creating files, appending large uploads, creating buckets)
+// throw this message. Reads, findInfo, and deletes still work — so clients can free space. Managed
+// by hostStorageServer's disk-space monitor.
+let writesRejectedReason;
+function setWritesRejectedReason(reason) {
+    writesRejectedReason = reason;
+}
+exports.setWritesRejectedReason = setWritesRejectedReason;
+function getWritesRejectedReason() {
+    return writesRejectedReason;
+}
+exports.getWritesRejectedReason = getWritesRejectedReason;
+function assertWritesAllowed() {
+    if (writesRejectedReason)
+        throw new Error(writesRejectedReason);
+}
+exports.assertWritesAllowed = assertWritesAllowed;
+// The system storages (trust, requests) are the same kind of thing — a JSON key/value store under
+// <folder>/system2/<name> — so they share one cache, keyed by name. ("system2" because the layout
+// changed when bucket configs moved into the buckets themselves; old "system"/"buckets" folders
+// are simply ignored.)
+// setTrustedMachines is called by consumers BEFORE starting the server, so when the config isn't
+// set yet we fall back to the same --folder arg the CLI starts the server with.
+function getStorageFolder() {
+    let config = getStorageServerConfigOptional();
+    if (config)
+        return config.folder;
+    let folder = (0, cliArgs_1.getArg)("folder");
+    if (!folder) {
+        throw new Error(`Storage server is not initialized and there is no --folder arg, so the storage folder is unknown`);
+    }
+    return path_1.default.resolve(folder);
+}
+const systemStorages = new Map();
+function getSystemStorage(name) {
+    let storage = systemStorages.get(name);
+    if (!storage) {
+        storage = (async () => {
+            let root = await (0, FileFolderAPI_1.getFileStorageNested2)(getStorageFolder());
+            let system = await root.folder.getStorage("system2");
+            let transactionName = "storage" + name[0].toUpperCase() + name.slice(1);
+            return new JSONStorage_1.JSONStorage(new TransactionStorage_1.TransactionStorage(await system.folder.getStorage(name), transactionName));
+        })();
+        systemStorages.set(name, storage);
+    }
+    return storage;
+}
+function getTrust() {
+    return getSystemStorage("trust");
+}
+exports.getTrust = getTrust;
+function getRequests() {
+    return getSystemStorage("requests");
+}
+exports.getRequests = getRequests;
+/** Makes machineIds the complete trust list for the account: machines not in the list lose access, machines already trusted keep their existing record, and missing ones are added. */
+async function setTrustedMachines(config) {
+    let trust = await getTrust();
+    let prefix = `${config.account}|`;
+    let desired = new Set(config.machineIds);
+    for (let key of await trust.getKeys()) {
+        if (!key.startsWith(prefix))
+            continue;
+        let machineId = key.slice(prefix.length);
+        if (desired.has(machineId)) {
+            desired.delete(machineId);
+            continue;
+        }
+        console.log(`Removing trust for machine ${machineId} on account ${config.account}`);
+        await trust.remove(key);
+    }
+    for (let machineId of desired) {
+        console.log(`Adding trust for machine ${machineId} on account ${config.account}`);
+        await trust.set(`${prefix}${machineId}`, { account: config.account, machineId, ip: "", time: Date.now() });
+    }
+}
+exports.setTrustedMachines = setTrustedMachines;
+const buckets = new Map();
+// setTimeout cannot represent longer delays; more distant window boundaries re-check after this
+const MAX_REBUILD_TIMER_DELAY = 2 ** 31 - 1;
+// Rebuild slightly after the boundary, so the newly-valid entry is unambiguously active
+const REBUILD_BOUNDARY_BUFFER = 1000;
+function getBucketFolder(account, bucketName) {
+    return path_1.default.join(getStorageServerConfig().folder, "buckets2", account, bucketName);
+}
+function findSelfIndexes(routing, account, bucketName) {
+    let { domain, port } = getStorageServerConfig();
+    let indexes = [];
+    for (let i = 0; i < routing.sources.length; i++) {
+        let source = routing.sources[i];
+        if (typeof source === "string" || source.type !== "remote")
+            continue;
+        let parsed = (0, remoteConfig_1.parseHostedUrl)(source.url);
+        if (parsed.address === domain && parsed.port === port && parsed.account === account && parsed.bucketName === bucketName) {
+            indexes.push(i);
+        }
+    }
+    return indexes;
+}
+// The entry whose valid window contains the time (among the entries covering the key's route,
+// when one is given - a server can hold different shards with different options). Half-open
+// ([start, end)), so clean breaks resolve unambiguously. Falls back to the nearest window when
+// none contains the time - gaps shouldn't exist, but a write must still resolve to SOME
+// configuration.
+function selectEntryAt(entries, time, route) {
+    if (route !== undefined) {
+        let covering = entries.filter(x => (0, remoteConfig_1.routeContains)(x.route, route));
+        if (covering.length) {
+            entries = covering;
+        }
+    }
+    let containing = entries.find(x => x.validWindow[0] <= time && time < x.validWindow[1]);
+    if (containing)
+        return containing;
+    let best;
+    let bestDistance = Infinity;
+    for (let entry of entries) {
+        let distance = Math.min(Math.abs(time - entry.validWindow[0]), Math.abs(time - entry.validWindow[1]));
+        if (distance < bestDistance) {
+            bestDistance = distance;
+            best = entry;
+        }
+    }
+    return best;
+}
+// Bucket options can change over time (multiple self entries with different valid windows), and
+// the structural ones (rawDisk, the downstream list) are baked into the store - so the store is
+// rebuilt shortly after each of our window boundaries passes, making the newly-valid entry apply.
+function scheduleWindowBoundaryRebuild(loaded) {
+    var _a, _b;
+    let now = Date.now();
+    let boundaries = loaded.selfEntries.flatMap(x => x.validWindow).filter(t => t > now);
+    if (!boundaries.length)
+        return;
+    let nextBoundary = Math.min(...boundaries);
+    let key = `${loaded.account}/${loaded.bucketName}`;
+    let timer = setTimeout(() => {
+        void (async () => {
+            // A routing change may have already replaced this store; only IT gets a boundary timer
+            let current = await buckets.get(key);
+            if (current !== loaded)
+                return;
+            if (Date.now() < nextBoundary) {
+                scheduleWindowBoundaryRebuild(loaded);
+                return;
+            }
+            await scheduleRoutingReload(loaded.account, loaded.bucketName, { force: true });
+        })();
+    }, Math.min(nextBoundary - now + REBUILD_BOUNDARY_BUFFER, MAX_REBUILD_TIMER_DELAY));
+    (_b = (_a = timer).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
+}
+function buildBucket(account, bucketName, routing) {
+    let folder = getBucketFolder(account, bucketName);
+    let selfIndexes = findSelfIndexes(routing, account, bucketName);
+    let selfEntries = selfIndexes.map(i => routing.sources[i]);
+    let self = selectEntryAt(selfEntries, Date.now());
+    let selfIndex = -1;
+    if (self) {
+        selfIndex = routing.sources.indexOf(self);
+    }
+    let store;
+    if (self === null || self === void 0 ? void 0 : self.rawDisk) {
+        store = new ArchivesDisk_1.ArchivesDisk(folder);
+    }
+    else {
+        // Our own disk is the base source; only the routing entries DOWNSTREAM from us (after our
+        // currently-valid entry) become synchronization sources. Upstream sources sync from us, so
+        // writing to or scanning them would just echo our own data back (and make our availability
+        // depend on theirs). A server NOT in the list has been removed from the bucket: it keeps
+        // its disk data (the config may re-add it), but stops all synchronization - no one
+        // contacts a removed source, and scanning/pushing as if we were still one would fight the
+        // real chain. The config-level validWindow rides on each ArchivesSource; the disk source
+        // shares our currently-valid entry's window (it holds our copy of the data).
+        let ownIndexes = new Set(selfIndexes);
+        // Our own disk gets no route filter: everything it holds is ours to index and serve
+        let sources = [{
+                source: new ArchivesDisk_1.ArchivesDisk(folder),
+                validWindow: (self === null || self === void 0 ? void 0 : self.validWindow) || IArchives_1.FULL_VALID_WINDOW,
+            }];
+        if (selfIndex === -1) {
+            console.log(`This server is not in the routing config for bucket ${account}/${bucketName}; keeping its data on disk but no longer synchronizing it`);
+        }
+        else {
+            for (let i = selfIndex + 1; i < routing.sources.length; i++) {
+                let source = routing.sources[i];
+                if (typeof source === "string" || ownIndexes.has(i))
+                    continue;
+                // Disjoint-shard sources never talk to each other; a partial overlap syncs only
+                // the intersection (scans ignore the rest, writes only send matching keys)
+                let sharedRoute = (0, remoteConfig_1.routeIntersection)(self === null || self === void 0 ? void 0 : self.route, source.route);
+                if (!sharedRoute)
+                    continue;
+                // A bounded-cache server (noFullSync on our own entry) must not full-sync from
+                // ANY source, or its disk would fill regardless of the limit
+                sources.push({ source: (0, createArchives_1.createApiArchives)(source), validWindow: source.validWindow, route: sharedRoute, noFullSync: source.noFullSync || (self === null || self === void 0 ? void 0 : self.noFullSync) });
+            }
+        }
+        store = new blobStore_1.BlobStore(folder, sources, {
+            onIndexChanged: key => {
+                // Fires for our own routing writes AND routing files pulled in via synchronization
+                // (only ever newer ones, see IArchives.set) — either way, apply the new config
+                if (key !== remoteConfig_1.ROUTING_FILE)
+                    return;
+                void scheduleRoutingReload(account, bucketName);
+            },
+            readerDiskLimit: self === null || self === void 0 ? void 0 : self.readerDiskLimit,
+        });
+    }
+    let loaded = { account, bucketName, routing, routingJSON: JSON.stringify(routing), selfEntries, self, store };
+    scheduleWindowBoundaryRebuild(loaded);
+    return loaded;
+}
+async function loadBucket(account, bucketName) {
+    let data = await new ArchivesDisk_1.ArchivesDisk(getBucketFolder(account, bucketName)).get(remoteConfig_1.ROUTING_FILE);
+    if (!data)
+        return undefined;
+    return buildBucket(account, bucketName, (0, remoteConfig_1.parseRoutingData)(data));
+}
+function getLoadedBucket(account, bucketName) {
+    let key = `${account}/${bucketName}`;
+    let loaded = buckets.get(key);
+    if (!loaded) {
+        loaded = loadBucket(account, bucketName);
+        buckets.set(key, loaded);
+        // Missing buckets are not cached — they can be created at any time (guarding against a
+        // concurrent create having already replaced our entry)
+        void loaded.then(bucket => {
+            if (!bucket && buckets.get(key) === loaded) {
+                buckets.delete(key);
+            }
+        }, () => {
+            if (buckets.get(key) === loaded) {
+                buckets.delete(key);
+            }
+        });
+    }
+    return loaded;
+}
+exports.getLoadedBucket = getLoadedBucket;
+// Routing reloads are serialized per bucket, so concurrent writes/syncs can't rebuild the same
+// store twice in parallel
+const routingReloads = new Map();
+function scheduleRoutingReload(account, bucketName, config) {
+    let key = `${account}/${bucketName}`;
+    let next = (routingReloads.get(key) || Promise.resolve())
+        .then(() => checkRoutingChanged(account, bucketName, config === null || config === void 0 ? void 0 : config.force))
+        .catch(e => console.error(`Reloading routing config for bucket ${key} failed:`, e));
+    routingReloads.set(key, next);
+    return next;
+}
+async function checkRoutingChanged(account, bucketName, force) {
+    let key = `${account}/${bucketName}`;
+    let loaded = await buckets.get(key);
+    if (!loaded)
+        return;
+    // get() cache-reads the file onto our disk when a remote source holds it, so the bucket still
+    // exists after a restart
+    let data = await loaded.store.get(remoteConfig_1.ROUTING_FILE);
+    if (!data)
+        return;
+    let routing = (0, remoteConfig_1.parseRoutingData)(data);
+    if (!force && JSON.stringify(routing) === loaded.routingJSON)
+        return;
+    if (force) {
+        console.log(`Rebuilding the store for bucket ${key} (a valid window boundary passed)`);
+    }
+    else {
+        console.log(`Routing config changed for bucket ${key}, rebuilding its store`);
+    }
+    if (loaded.store instanceof blobStore_1.BlobStore) {
+        await loaded.store.dispose();
+    }
+    buckets.set(key, Promise.resolve(buildBucket(account, bucketName, routing)));
+}
+// Per-write options are evaluated at the WRITE's time (and the key's route), not the current
+// config: the write time is stamped exactly once (at the first node that receives the write) and
+// propagates with the data, so every node resolves the same self entry - and the same options.
+function getWriteConfig(bucket, writeTime, route) {
+    let self = selectEntryAt(bucket.selfEntries, writeTime, route);
+    return { fast: self === null || self === void 0 ? void 0 : self.fast, writeDelay: self === null || self === void 0 ? void 0 : self.writeDelay };
+}
+async function assertMutable(bucket, filePath, writeTime) {
+    let self = selectEntryAt(bucket.selfEntries, writeTime, (0, remoteConfig_1.getRoute)(filePath));
+    if (!(self === null || self === void 0 ? void 0 : self.immutable))
+        return;
+    if (await bucket.store.getInfo(filePath)) {
+        throw new Error(`Bucket ${bucket.account}/${bucket.bucketName} is immutable (at write time ${writeTime}) and ${JSON.stringify(filePath)} already exists, so it cannot be written to`);
+    }
+}
+exports.assertMutable = assertMutable;
+// Routing writes are serialized per bucket, so two concurrent creates can't both build a store
+// (the loser's store would leak with its sync loops running forever)
+const routingWrites = new Map();
+async function writeRoutingConfig(account, bucketName, data, config) {
+    let key = `${account}/${bucketName}`;
+    // Validates before storing anything, so a bad config can't brick the bucket
+    let incoming = (0, remoteConfig_1.parseRoutingData)(data);
+    let loaded = await getLoadedBucket(account, bucketName);
+    if (!loaded) {
+        await new ArchivesDisk_1.ArchivesDisk(getBucketFolder(account, bucketName)).set(remoteConfig_1.ROUTING_FILE, data, { lastModified: config === null || config === void 0 ? void 0 : config.lastModified });
+        buckets.set(key, Promise.resolve(buildBucket(account, bucketName, incoming)));
+        console.log(`Created bucket ${key}`);
+        return;
+    }
+    // A changed config must carry a higher version than the one currently stored — otherwise two
+    // clients with different configs at the same version would keep clobbering each other. Same
+    // content at any version is a harmless no-op and is allowed through.
+    if (JSON.stringify(incoming) !== loaded.routingJSON && (0, remoteConfig_1.getConfigVersion)(incoming) <= (0, remoteConfig_1.getConfigVersion)(loaded.routing)) {
+        throw new Error(`Cannot update routing config for bucket ${key}: the new config differs from the current one but its version (${(0, remoteConfig_1.getConfigVersion)(incoming)}) is not greater than the current version (${(0, remoteConfig_1.getConfigVersion)(loaded.routing)}). Increment the version to update it. Current: ${loaded.routingJSON}. Attempted: ${JSON.stringify(incoming)}`);
+    }
+    // Routing writes bypass fast mode (the config must apply immediately and survive a crash)
+    // and ignore immutable (the routing file must always stay updatable). An older lastModified
+    // no-ops inside set, in which case the reload below sees no change.
+    await loaded.store.set(remoteConfig_1.ROUTING_FILE, data, { lastModified: config === null || config === void 0 ? void 0 : config.lastModified });
+    await scheduleRoutingReload(account, bucketName);
+}
+async function writeBucketFile(account, bucketName, filePath, data, config) {
+    assertWritesAllowed();
+    if (filePath === remoteConfig_1.ROUTING_FILE) {
+        let key = `${account}/${bucketName}`;
+        let run = (routingWrites.get(key) || Promise.resolve()).then(() => writeRoutingConfig(account, bucketName, data, config));
+        // The chain must survive a failed write, so the stored link swallows the error (the caller
+        // still gets it from run)
+        routingWrites.set(key, run.then(() => { }, () => { }));
+        return await run;
+    }
+    let loaded = await getLoadedBucket(account, bucketName);
+    if (!loaded) {
+        throw new Error(`Bucket ${account}/${bucketName} does not exist. Write its routing config to ${JSON.stringify(remoteConfig_1.ROUTING_FILE)} to create it.`);
+    }
+    // The write time is determined exactly once, HERE at the first node that receives the write;
+    // it propagates as lastModified, so every node evaluates the bucket options at the same instant
+    let writeTime = (config === null || config === void 0 ? void 0 : config.lastModified) || Date.now();
+    // Only freshly-stamped writes are checked: a write with an explicit lastModified is
+    // synchronization/backfill (old data legitimately lands on sources whose window has moved on),
+    // but a fresh write reaching us outside our windows/routes means the client resolved its
+    // target from a stale view - it must re-resolve and retry at the correct source.
+    let route = (0, remoteConfig_1.getRoute)(filePath);
+    if (!(config === null || config === void 0 ? void 0 : config.lastModified) && loaded.selfEntries.length) {
+        let timeValid = loaded.selfEntries.filter(x => writeTime >= x.validWindow[0] - IArchives_1.WRITE_PAST_WINDOW_GRACE && writeTime <= x.validWindow[1] + IArchives_1.WRITE_PAST_WINDOW_GRACE);
+        if (!timeValid.length) {
+            throw new Error(`${IArchives_1.STORAGE_WRONG_VALID_WINDOW} This server is not a valid write target at ${writeTime} for bucket ${account}/${bucketName} (our valid windows: ${JSON.stringify(loaded.selfEntries.map(x => x.validWindow))}). Re-resolve the currently valid source and retry.`);
+        }
+        if (!timeValid.some(x => (0, remoteConfig_1.routeContains)(x.route, route))) {
+            throw new Error(`${IArchives_1.STORAGE_WRONG_ROUTE} This server does not handle route ${route} (key ${JSON.stringify(filePath)}) for bucket ${account}/${bucketName} (our routes at this time: ${JSON.stringify(timeValid.map(x => x.route || IArchives_1.FULL_ROUTE))}). Re-resolve the source for this key and retry.`);
+        }
+    }
+    await assertMutable(loaded, filePath, writeTime);
+    await loaded.store.set(filePath, data, { ...getWriteConfig(loaded, writeTime, route), lastModified: writeTime });
+}
+exports.writeBucketFile = writeBucketFile;
+async function deleteBucketFile(account, bucketName, filePath) {
+    if (filePath === remoteConfig_1.ROUTING_FILE) {
+        throw new Error(`The routing config ${JSON.stringify(remoteConfig_1.ROUTING_FILE)} cannot be deleted (overwrite it to change the bucket's configuration)`);
+    }
+    let loaded = await getLoadedBucket(account, bucketName);
+    if (!loaded)
+        return;
+    await loaded.store.del(filePath, getWriteConfig(loaded, Date.now(), (0, remoteConfig_1.getRoute)(filePath)));
+}
+exports.deleteBucketFile = deleteBucketFile;
+// ── local IArchives access ──
+const LARGE_FILE_PART_SIZE = 8 * 1024 * 1024;
+// The in-process IArchives for a bucket hosted by THIS server — used when a RemoteConfig source
+// URL points at ourselves, so we don't talk to ourselves over HTTPS. One singleton per bucket.
+class ArchivesLocalBucket {
+    constructor(account, bucketName) {
+        this.account = account;
+        this.bucketName = bucketName;
+    }
+    async getBucket() {
+        return await getLoadedBucket(this.account, this.bucketName);
+    }
+    getDebugName() {
+        return `localBucket/${this.account}/${this.bucketName}`;
+    }
+    async get(fileName, config) {
+        let result = await this.get2(fileName, config);
+        return result && result.data || undefined;
+    }
+    async get2(fileName, config) {
+        let bucket = await this.getBucket();
+        if (!bucket)
+            return undefined;
+        return await bucket.store.get2(fileName, config);
+    }
+    async set(fileName, data, config) {
+        await writeBucketFile(this.account, this.bucketName, fileName, data, config);
+    }
+    async del(fileName) {
+        await deleteBucketFile(this.account, this.bucketName, fileName);
+    }
+    async setLargeFile(config) {
+        assertWritesAllowed();
+        let bucket = await this.getBucket();
+        if (!bucket) {
+            throw new Error(`Bucket ${this.account}/${this.bucketName} does not exist. Write its routing config to ${JSON.stringify(remoteConfig_1.ROUTING_FILE)} to create it.`);
+        }
+        await assertMutable(bucket, config.path, Date.now());
+        let id = await bucket.store.startLargeUpload();
+        try {
+            while (true) {
+                let data = await config.getNextData();
+                if (!data)
+                    break;
+                for (let offset = 0; offset < data.length; offset += LARGE_FILE_PART_SIZE) {
+                    await bucket.store.appendLargeUpload(id, data.subarray(offset, offset + LARGE_FILE_PART_SIZE));
+                }
+            }
+            await bucket.store.finishLargeUpload(id, config.path);
+        }
+        catch (e) {
+            await bucket.store.cancelLargeUpload(id);
+            throw e;
+        }
+    }
+    async getInfo(fileName) {
+        let bucket = await this.getBucket();
+        if (!bucket)
+            return undefined;
+        return await bucket.store.getInfo(fileName);
+    }
+    async findInfo(prefix, config) {
+        let bucket = await this.getBucket();
+        if (!bucket)
+            return [];
+        return await bucket.store.findInfo(prefix, config);
+    }
+    async find(prefix, config) {
+        return (await this.findInfo(prefix, config)).map(x => x.path);
+    }
+    async getURL(filePath) {
+        let { domain, port } = getStorageServerConfig();
+        return (0, remoteConfig_1.buildFileUrl)(`https://${domain}:${port}/file/${encodeURIComponent(this.account)}/${encodeURIComponent(this.bucketName)}`, filePath);
+    }
+    async getConfig() {
+        var _a, _b;
+        let bucket = await this.getBucket();
+        // Missing buckets say true, matching what they become once created (the default store type)
+        let progress = (_b = bucket === null || bucket === void 0 ? void 0 : (_a = bucket.store).getSyncProgress) === null || _b === void 0 ? void 0 : _b.call(_a);
+        return {
+            supportsChangesAfter: !bucket || !!bucket.store.getChangesAfter,
+            remoteConfig: bucket === null || bucket === void 0 ? void 0 : bucket.routing,
+            index: progress === null || progress === void 0 ? void 0 : progress.index,
+            indexSources: progress === null || progress === void 0 ? void 0 : progress.sources,
+            readerDiskLimit: progress === null || progress === void 0 ? void 0 : progress.readerDiskLimit,
+            syncing: progress === null || progress === void 0 ? void 0 : progress.syncing,
+        };
+    }
+    async hasWriteAccess() {
+        return true;
+    }
+    async getChangesAfter(time) {
+        let bucket = await this.getBucket();
+        if (!bucket)
+            return [];
+        if (!bucket.store.getChangesAfter) {
+            throw new Error(`Bucket ${this.account}/${this.bucketName} does not support getChangesAfter (rawDisk buckets have no index)`);
+        }
+        return await bucket.store.getChangesAfter(time);
+    }
+    async getSyncStatus() {
+        let bucket = await this.getBucket();
+        if (!bucket)
+            return { allScansComplete: true, indexSize: 0, sources: [] };
+        if (!bucket.store.getSyncStatus) {
+            throw new Error(`Bucket ${this.account}/${this.bucketName} does not support getSyncStatus (rawDisk buckets have no synchronization)`);
+        }
+        return await bucket.store.getSyncStatus();
+    }
+}
+const localArchives = new Map();
+function getLocalArchives(account, bucketName) {
+    let key = `${account}/${bucketName}`;
+    let existing = localArchives.get(key);
+    if (existing)
+        return existing;
+    let archives = new ArchivesLocalBucket(account, bucketName);
+    localArchives.set(key, archives);
+    return archives;
+}
+exports.getLocalArchives = getLocalArchives;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"storageServerState.js","sourceRoot":"","sources":["storageServerState.ts"],"names":[],"mappings":"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","sourcesContent":["import path from \"path\";\nimport { getFileStorageNested2 } from \"../FileFolderAPI\";\nimport { TransactionStorage } from \"../TransactionStorage\";\nimport { JSONStorage } from \"../JSONStorage\";\nimport { ArchivesDisk } from \"../ArchivesDisk\";\nimport { BlobStore, IBucketStore } from \"./blobStore\";\nimport {\n    RemoteConfig, HostedConfig, IArchives, ArchivesSource, ArchiveFileInfo, ArchivesConfig,\n    ArchivesSyncStatus, FULL_VALID_WINDOW,\n    WRITE_PAST_WINDOW_GRACE, STORAGE_WRONG_VALID_WINDOW, STORAGE_WRONG_ROUTE, FULL_ROUTE,\n} from \"../IArchives\";\nimport { ROUTING_FILE, parseRoutingData, parseHostedUrl, buildFileUrl, getConfigVersion, getRoute, routeContains, routeIntersection } from \"./remoteConfig\";\nimport { createApiArchives } from \"./createArchives\";\nimport type { IStorage } from \"../IStorage\";\nimport type { AccessRequest, TrustRecord } from \"./storageController\";\nimport { getArg } from \"./cliArgs\";\n\n// The storage server's global server-side state. hostStorageServer sets the config once at\n// startup; everything else (system storages, buckets) is a global cache created lazily on first\n// use, throwing if the config was never set.\n//\n// Buckets have no separate registry: each bucket's configuration (a RemoteConfig) lives inside the\n// bucket itself, at ROUTING_FILE. A bucket exists iff that file exists. Writing it creates the\n// bucket (building its store, which may immediately start synchronization scans); overwriting it —\n// directly or via a file pulled in from a synchronization source — rebuilds the store with the new\n// sources (cancelling the old store's scans).\n\nexport type StorageServerConfig = {\n    domain: string;\n    port: number;\n    rootDomain: string;\n    // user@externalIp of the storage machine, for generated ssh commands\n    sshTarget: string;\n    // Absolute command that runs the grantAccess CLI on the storage machine (admin args appended)\n    serverCommand: string;\n    // The server's root storage folder (absolute)\n    folder: string;\n};\n\nlet config: StorageServerConfig | undefined;\nexport function setStorageServerConfig(value: StorageServerConfig): void {\n    config = value;\n}\nexport function getStorageServerConfig(): StorageServerConfig {\n    if (!config) {\n        throw new Error(`Storage server is not initialized (this API only works on the storage server)`);\n    }\n    return config;\n}\n// For self-detection: code that CAN run outside the storage server (createArchives) uses this to\n// check \"is this URL our own process?\" without throwing.\nexport function getStorageServerConfigOptional(): StorageServerConfig | undefined {\n    return config;\n}\n\n// When set, all write-path operations (creating files, appending large uploads, creating buckets)\n// throw this message. Reads, findInfo, and deletes still work — so clients can free space. Managed\n// by hostStorageServer's disk-space monitor.\nlet writesRejectedReason: string | undefined;\nexport function setWritesRejectedReason(reason: string | undefined): void {\n    writesRejectedReason = reason;\n}\nexport function getWritesRejectedReason(): string | undefined {\n    return writesRejectedReason;\n}\nexport function assertWritesAllowed(): void {\n    if (writesRejectedReason) throw new Error(writesRejectedReason);\n}\n\n// The system storages (trust, requests) are the same kind of thing — a JSON key/value store under\n// <folder>/system2/<name> — so they share one cache, keyed by name. (\"system2\" because the layout\n// changed when bucket configs moved into the buckets themselves; old \"system\"/\"buckets\" folders\n// are simply ignored.)\n// setTrustedMachines is called by consumers BEFORE starting the server, so when the config isn't\n// set yet we fall back to the same --folder arg the CLI starts the server with.\nfunction getStorageFolder(): string {\n    let config = getStorageServerConfigOptional();\n    if (config) return config.folder;\n    let folder = getArg(\"folder\");\n    if (!folder) {\n        throw new Error(`Storage server is not initialized and there is no --folder arg, so the storage folder is unknown`);\n    }\n    return path.resolve(folder);\n}\n\nconst systemStorages = new Map<string, Promise<IStorage<unknown>>>();\nfunction getSystemStorage<T>(name: string): Promise<IStorage<T>> {\n    let storage = systemStorages.get(name);\n    if (!storage) {\n        storage = (async () => {\n            let root = await getFileStorageNested2(getStorageFolder());\n            let system = await root.folder.getStorage(\"system2\");\n            let transactionName = \"storage\" + name[0].toUpperCase() + name.slice(1);\n            return new JSONStorage<unknown>(new TransactionStorage(await system.folder.getStorage(name), transactionName));\n        })();\n        systemStorages.set(name, storage);\n    }\n    return storage as Promise<IStorage<T>>;\n}\nexport function getTrust(): Promise<IStorage<TrustRecord>> {\n    return getSystemStorage<TrustRecord>(\"trust\");\n}\nexport function getRequests(): Promise<IStorage<AccessRequest[]>> {\n    return getSystemStorage<AccessRequest[]>(\"requests\");\n}\n\n/** Makes machineIds the complete trust list for the account: machines not in the list lose access, machines already trusted keep their existing record, and missing ones are added. */\nexport async function setTrustedMachines(config: { account: string; machineIds: string[] }): Promise<void> {\n    let trust = await getTrust();\n    let prefix = `${config.account}|`;\n    let desired = new Set(config.machineIds);\n    for (let key of await trust.getKeys()) {\n        if (!key.startsWith(prefix)) continue;\n        let machineId = key.slice(prefix.length);\n        if (desired.has(machineId)) {\n            desired.delete(machineId);\n            continue;\n        }\n        console.log(`Removing trust for machine ${machineId} on account ${config.account}`);\n        await trust.remove(key);\n    }\n    for (let machineId of desired) {\n        console.log(`Adding trust for machine ${machineId} on account ${config.account}`);\n        await trust.set(`${prefix}${machineId}`, { account: config.account, machineId, ip: \"\", time: Date.now() });\n    }\n}\n\n// ── buckets ──\n\nexport type LoadedBucket = {\n    account: string;\n    bucketName: string;\n    // The bucket's parsed routing config (the contents of ROUTING_FILE)\n    routing: RemoteConfig;\n    // JSON of routing, for change detection\n    routingJSON: string;\n    // ALL of our own entries in routing.sources (this bucket on this server). More than one when\n    // the bucket's options change over time - one entry per valid window (e.g. immutable dropped,\n    // or fast enabled, starting at a scheduled instant).\n    selfEntries: HostedConfig[];\n    // The entry valid when the store was built - the structural options (rawDisk, which entries\n    // are downstream). Per-write options (fast/immutable) are instead evaluated at each write's\n    // time, see getWriteConfig/assertMutable. undefined when the config doesn't mention us.\n    self: HostedConfig | undefined;\n    store: IBucketStore;\n};\n\nconst buckets = new Map<string, Promise<LoadedBucket | undefined>>();\n\n// setTimeout cannot represent longer delays; more distant window boundaries re-check after this\nconst MAX_REBUILD_TIMER_DELAY = 2 ** 31 - 1;\n// Rebuild slightly after the boundary, so the newly-valid entry is unambiguously active\nconst REBUILD_BOUNDARY_BUFFER = 1000;\n\nfunction getBucketFolder(account: string, bucketName: string): string {\n    return path.join(getStorageServerConfig().folder, \"buckets2\", account, bucketName);\n}\n\nfunction findSelfIndexes(routing: RemoteConfig, account: string, bucketName: string): number[] {\n    let { domain, port } = getStorageServerConfig();\n    let indexes: number[] = [];\n    for (let i = 0; i < routing.sources.length; i++) {\n        let source = routing.sources[i];\n        if (typeof source === \"string\" || source.type !== \"remote\") continue;\n        let parsed = parseHostedUrl(source.url);\n        if (parsed.address === domain && parsed.port === port && parsed.account === account && parsed.bucketName === bucketName) {\n            indexes.push(i);\n        }\n    }\n    return indexes;\n}\n\n// The entry whose valid window contains the time (among the entries covering the key's route,\n// when one is given - a server can hold different shards with different options). Half-open\n// ([start, end)), so clean breaks resolve unambiguously. Falls back to the nearest window when\n// none contains the time - gaps shouldn't exist, but a write must still resolve to SOME\n// configuration.\nfunction selectEntryAt(entries: HostedConfig[], time: number, route?: number): HostedConfig | undefined {\n    if (route !== undefined) {\n        let covering = entries.filter(x => routeContains(x.route, route));\n        if (covering.length) {\n            entries = covering;\n        }\n    }\n    let containing = entries.find(x => x.validWindow[0] <= time && time < x.validWindow[1]);\n    if (containing) return containing;\n    let best: HostedConfig | undefined;\n    let bestDistance = Infinity;\n    for (let entry of entries) {\n        let distance = Math.min(Math.abs(time - entry.validWindow[0]), Math.abs(time - entry.validWindow[1]));\n        if (distance < bestDistance) {\n            bestDistance = distance;\n            best = entry;\n        }\n    }\n    return best;\n}\n\n// Bucket options can change over time (multiple self entries with different valid windows), and\n// the structural ones (rawDisk, the downstream list) are baked into the store - so the store is\n// rebuilt shortly after each of our window boundaries passes, making the newly-valid entry apply.\nfunction scheduleWindowBoundaryRebuild(loaded: LoadedBucket): void {\n    let now = Date.now();\n    let boundaries = loaded.selfEntries.flatMap(x => x.validWindow).filter(t => t > now);\n    if (!boundaries.length) return;\n    let nextBoundary = Math.min(...boundaries);\n    let key = `${loaded.account}/${loaded.bucketName}`;\n    let timer = setTimeout(() => {\n        void (async () => {\n            // A routing change may have already replaced this store; only IT gets a boundary timer\n            let current = await buckets.get(key);\n            if (current !== loaded) return;\n            if (Date.now() < nextBoundary) {\n                scheduleWindowBoundaryRebuild(loaded);\n                return;\n            }\n            await scheduleRoutingReload(loaded.account, loaded.bucketName, { force: true });\n        })();\n    }, Math.min(nextBoundary - now + REBUILD_BOUNDARY_BUFFER, MAX_REBUILD_TIMER_DELAY));\n    (timer as { unref?: () => void }).unref?.();\n}\n\nfunction buildBucket(account: string, bucketName: string, routing: RemoteConfig): LoadedBucket {\n    let folder = getBucketFolder(account, bucketName);\n    let selfIndexes = findSelfIndexes(routing, account, bucketName);\n    let selfEntries = selfIndexes.map(i => routing.sources[i] as HostedConfig);\n    let self = selectEntryAt(selfEntries, Date.now());\n    let selfIndex = -1;\n    if (self) {\n        selfIndex = routing.sources.indexOf(self);\n    }\n    let store: IBucketStore;\n    if (self?.rawDisk) {\n        store = new ArchivesDisk(folder);\n    } else {\n        // Our own disk is the base source; only the routing entries DOWNSTREAM from us (after our\n        // currently-valid entry) become synchronization sources. Upstream sources sync from us, so\n        // writing to or scanning them would just echo our own data back (and make our availability\n        // depend on theirs). A server NOT in the list has been removed from the bucket: it keeps\n        // its disk data (the config may re-add it), but stops all synchronization - no one\n        // contacts a removed source, and scanning/pushing as if we were still one would fight the\n        // real chain. The config-level validWindow rides on each ArchivesSource; the disk source\n        // shares our currently-valid entry's window (it holds our copy of the data).\n        let ownIndexes = new Set(selfIndexes);\n        // Our own disk gets no route filter: everything it holds is ours to index and serve\n        let sources: ArchivesSource[] = [{\n            source: new ArchivesDisk(folder),\n            validWindow: self?.validWindow || FULL_VALID_WINDOW,\n        }];\n        if (selfIndex === -1) {\n            console.log(`This server is not in the routing config for bucket ${account}/${bucketName}; keeping its data on disk but no longer synchronizing it`);\n        } else {\n            for (let i = selfIndex + 1; i < routing.sources.length; i++) {\n                let source = routing.sources[i];\n                if (typeof source === \"string\" || ownIndexes.has(i)) continue;\n                // Disjoint-shard sources never talk to each other; a partial overlap syncs only\n                // the intersection (scans ignore the rest, writes only send matching keys)\n                let sharedRoute = routeIntersection(self?.route, source.route);\n                if (!sharedRoute) continue;\n                // A bounded-cache server (noFullSync on our own entry) must not full-sync from\n                // ANY source, or its disk would fill regardless of the limit\n                sources.push({ source: createApiArchives(source), validWindow: source.validWindow, route: sharedRoute, noFullSync: source.noFullSync || self?.noFullSync });\n            }\n        }\n        store = new BlobStore(folder, sources, {\n            onIndexChanged: key => {\n                // Fires for our own routing writes AND routing files pulled in via synchronization\n                // (only ever newer ones, see IArchives.set) — either way, apply the new config\n                if (key !== ROUTING_FILE) return;\n                void scheduleRoutingReload(account, bucketName);\n            },\n            readerDiskLimit: self?.readerDiskLimit,\n        });\n    }\n    let loaded: LoadedBucket = { account, bucketName, routing, routingJSON: JSON.stringify(routing), selfEntries, self, store };\n    scheduleWindowBoundaryRebuild(loaded);\n    return loaded;\n}\n\nasync function loadBucket(account: string, bucketName: string): Promise<LoadedBucket | undefined> {\n    let data = await new ArchivesDisk(getBucketFolder(account, bucketName)).get(ROUTING_FILE);\n    if (!data) return undefined;\n    return buildBucket(account, bucketName, parseRoutingData(data));\n}\n\nexport function getLoadedBucket(account: string, bucketName: string): Promise<LoadedBucket | undefined> {\n    let key = `${account}/${bucketName}`;\n    let loaded = buckets.get(key);\n    if (!loaded) {\n        loaded = loadBucket(account, bucketName);\n        buckets.set(key, loaded);\n        // Missing buckets are not cached — they can be created at any time (guarding against a\n        // concurrent create having already replaced our entry)\n        void loaded.then(bucket => {\n            if (!bucket && buckets.get(key) === loaded) {\n                buckets.delete(key);\n            }\n        }, () => {\n            if (buckets.get(key) === loaded) {\n                buckets.delete(key);\n            }\n        });\n    }\n    return loaded;\n}\n\n// Routing reloads are serialized per bucket, so concurrent writes/syncs can't rebuild the same\n// store twice in parallel\nconst routingReloads = new Map<string, Promise<void>>();\nfunction scheduleRoutingReload(account: string, bucketName: string, config?: { force?: boolean }): Promise<void> {\n    let key = `${account}/${bucketName}`;\n    let next = (routingReloads.get(key) || Promise.resolve())\n        .then(() => checkRoutingChanged(account, bucketName, config?.force))\n        .catch(e => console.error(`Reloading routing config for bucket ${key} failed:`, e));\n    routingReloads.set(key, next);\n    return next;\n}\n\nasync function checkRoutingChanged(account: string, bucketName: string, force?: boolean): Promise<void> {\n    let key = `${account}/${bucketName}`;\n    let loaded = await buckets.get(key);\n    if (!loaded) return;\n    // get() cache-reads the file onto our disk when a remote source holds it, so the bucket still\n    // exists after a restart\n    let data = await loaded.store.get(ROUTING_FILE);\n    if (!data) return;\n    let routing = parseRoutingData(data);\n    if (!force && JSON.stringify(routing) === loaded.routingJSON) return;\n    if (force) {\n        console.log(`Rebuilding the store for bucket ${key} (a valid window boundary passed)`);\n    } else {\n        console.log(`Routing config changed for bucket ${key}, rebuilding its store`);\n    }\n    if (loaded.store instanceof BlobStore) {\n        await loaded.store.dispose();\n    }\n    buckets.set(key, Promise.resolve(buildBucket(account, bucketName, routing)));\n}\n\n// Per-write options are evaluated at the WRITE's time (and the key's route), not the current\n// config: the write time is stamped exactly once (at the first node that receives the write) and\n// propagates with the data, so every node resolves the same self entry - and the same options.\nfunction getWriteConfig(bucket: LoadedBucket, writeTime: number, route: number): { fast?: boolean; writeDelay?: number } {\n    let self = selectEntryAt(bucket.selfEntries, writeTime, route);\n    return { fast: self?.fast, writeDelay: self?.writeDelay };\n}\n\nexport async function assertMutable(bucket: LoadedBucket, filePath: string, writeTime: number): Promise<void> {\n    let self = selectEntryAt(bucket.selfEntries, writeTime, getRoute(filePath));\n    if (!self?.immutable) return;\n    if (await bucket.store.getInfo(filePath)) {\n        throw new Error(`Bucket ${bucket.account}/${bucket.bucketName} is immutable (at write time ${writeTime}) and ${JSON.stringify(filePath)} already exists, so it cannot be written to`);\n    }\n}\n\n// Routing writes are serialized per bucket, so two concurrent creates can't both build a store\n// (the loser's store would leak with its sync loops running forever)\nconst routingWrites = new Map<string, Promise<void>>();\n\nasync function writeRoutingConfig(account: string, bucketName: string, data: Buffer, config?: { lastModified?: number }): Promise<void> {\n    let key = `${account}/${bucketName}`;\n    // Validates before storing anything, so a bad config can't brick the bucket\n    let incoming = parseRoutingData(data);\n    let loaded = await getLoadedBucket(account, bucketName);\n    if (!loaded) {\n        await new ArchivesDisk(getBucketFolder(account, bucketName)).set(ROUTING_FILE, data, { lastModified: config?.lastModified });\n        buckets.set(key, Promise.resolve(buildBucket(account, bucketName, incoming)));\n        console.log(`Created bucket ${key}`);\n        return;\n    }\n    // A changed config must carry a higher version than the one currently stored — otherwise two\n    // clients with different configs at the same version would keep clobbering each other. Same\n    // content at any version is a harmless no-op and is allowed through.\n    if (JSON.stringify(incoming) !== loaded.routingJSON && getConfigVersion(incoming) <= getConfigVersion(loaded.routing)) {\n        throw new Error(`Cannot update routing config for bucket ${key}: the new config differs from the current one but its version (${getConfigVersion(incoming)}) is not greater than the current version (${getConfigVersion(loaded.routing)}). Increment the version to update it. Current: ${loaded.routingJSON}. Attempted: ${JSON.stringify(incoming)}`);\n    }\n    // Routing writes bypass fast mode (the config must apply immediately and survive a crash)\n    // and ignore immutable (the routing file must always stay updatable). An older lastModified\n    // no-ops inside set, in which case the reload below sees no change.\n    await loaded.store.set(ROUTING_FILE, data, { lastModified: config?.lastModified });\n    await scheduleRoutingReload(account, bucketName);\n}\n\nexport async function writeBucketFile(account: string, bucketName: string, filePath: string, data: Buffer, config?: { lastModified?: number }): Promise<void> {\n    assertWritesAllowed();\n    if (filePath === ROUTING_FILE) {\n        let key = `${account}/${bucketName}`;\n        let run = (routingWrites.get(key) || Promise.resolve()).then(() => writeRoutingConfig(account, bucketName, data, config));\n        // The chain must survive a failed write, so the stored link swallows the error (the caller\n        // still gets it from run)\n        routingWrites.set(key, run.then(() => { }, () => { }));\n        return await run;\n    }\n    let loaded = await getLoadedBucket(account, bucketName);\n    if (!loaded) {\n        throw new Error(`Bucket ${account}/${bucketName} does not exist. Write its routing config to ${JSON.stringify(ROUTING_FILE)} to create it.`);\n    }\n    // The write time is determined exactly once, HERE at the first node that receives the write;\n    // it propagates as lastModified, so every node evaluates the bucket options at the same instant\n    let writeTime = config?.lastModified || Date.now();\n    // Only freshly-stamped writes are checked: a write with an explicit lastModified is\n    // synchronization/backfill (old data legitimately lands on sources whose window has moved on),\n    // but a fresh write reaching us outside our windows/routes means the client resolved its\n    // target from a stale view - it must re-resolve and retry at the correct source.\n    let route = getRoute(filePath);\n    if (!config?.lastModified && loaded.selfEntries.length) {\n        let timeValid = loaded.selfEntries.filter(x => writeTime >= x.validWindow[0] - WRITE_PAST_WINDOW_GRACE && writeTime <= x.validWindow[1] + WRITE_PAST_WINDOW_GRACE);\n        if (!timeValid.length) {\n            throw new Error(`${STORAGE_WRONG_VALID_WINDOW} This server is not a valid write target at ${writeTime} for bucket ${account}/${bucketName} (our valid windows: ${JSON.stringify(loaded.selfEntries.map(x => x.validWindow))}). Re-resolve the currently valid source and retry.`);\n        }\n        if (!timeValid.some(x => routeContains(x.route, route))) {\n            throw new Error(`${STORAGE_WRONG_ROUTE} This server does not handle route ${route} (key ${JSON.stringify(filePath)}) for bucket ${account}/${bucketName} (our routes at this time: ${JSON.stringify(timeValid.map(x => x.route || FULL_ROUTE))}). Re-resolve the source for this key and retry.`);\n        }\n    }\n    await assertMutable(loaded, filePath, writeTime);\n    await loaded.store.set(filePath, data, { ...getWriteConfig(loaded, writeTime, route), lastModified: writeTime });\n}\n\nexport async function deleteBucketFile(account: string, bucketName: string, filePath: string): Promise<void> {\n    if (filePath === ROUTING_FILE) {\n        throw new Error(`The routing config ${JSON.stringify(ROUTING_FILE)} cannot be deleted (overwrite it to change the bucket's configuration)`);\n    }\n    let loaded = await getLoadedBucket(account, bucketName);\n    if (!loaded) return;\n    await loaded.store.del(filePath, getWriteConfig(loaded, Date.now(), getRoute(filePath)));\n}\n\n// ── local IArchives access ──\n\nconst LARGE_FILE_PART_SIZE = 8 * 1024 * 1024;\n\n// The in-process IArchives for a bucket hosted by THIS server — used when a RemoteConfig source\n// URL points at ourselves, so we don't talk to ourselves over HTTPS. One singleton per bucket.\nclass ArchivesLocalBucket implements IArchives {\n    constructor(private account: string, private bucketName: string) { }\n\n    private async getBucket(): Promise<LoadedBucket | undefined> {\n        return await getLoadedBucket(this.account, this.bucketName);\n    }\n\n    public getDebugName() {\n        return `localBucket/${this.account}/${this.bucketName}`;\n    }\n    public async get(fileName: string, config?: { range?: { start: number; end: number } }): Promise<Buffer | undefined> {\n        let result = await this.get2(fileName, config);\n        return result && result.data || undefined;\n    }\n    public async get2(fileName: string, config?: { range?: { start: number; end: number } }): Promise<{ data: Buffer; writeTime: number; size: number } | undefined> {\n        let bucket = await this.getBucket();\n        if (!bucket) return undefined;\n        return await bucket.store.get2(fileName, config);\n    }\n    public async set(fileName: string, data: Buffer, config?: { lastModified?: number }): Promise<void> {\n        await writeBucketFile(this.account, this.bucketName, fileName, data, config);\n    }\n    public async del(fileName: string): Promise<void> {\n        await deleteBucketFile(this.account, this.bucketName, fileName);\n    }\n    public async setLargeFile(config: { path: string; getNextData(): Promise<Buffer | undefined> }): Promise<void> {\n        assertWritesAllowed();\n        let bucket = await this.getBucket();\n        if (!bucket) {\n            throw new Error(`Bucket ${this.account}/${this.bucketName} does not exist. Write its routing config to ${JSON.stringify(ROUTING_FILE)} to create it.`);\n        }\n        await assertMutable(bucket, config.path, Date.now());\n        let id = await bucket.store.startLargeUpload();\n        try {\n            while (true) {\n                let data = await config.getNextData();\n                if (!data) break;\n                for (let offset = 0; offset < data.length; offset += LARGE_FILE_PART_SIZE) {\n                    await bucket.store.appendLargeUpload(id, data.subarray(offset, offset + LARGE_FILE_PART_SIZE));\n                }\n            }\n            await bucket.store.finishLargeUpload(id, config.path);\n        } catch (e) {\n            await bucket.store.cancelLargeUpload(id);\n            throw e;\n        }\n    }\n    public async getInfo(fileName: string): Promise<{ writeTime: number; size: number } | undefined> {\n        let bucket = await this.getBucket();\n        if (!bucket) return undefined;\n        return await bucket.store.getInfo(fileName);\n    }\n    public async findInfo(prefix: string, config?: { shallow?: boolean; type: \"files\" | \"folders\" }): Promise<ArchiveFileInfo[]> {\n        let bucket = await this.getBucket();\n        if (!bucket) return [];\n        return await bucket.store.findInfo(prefix, config);\n    }\n    public async find(prefix: string, config?: { shallow?: boolean; type: \"files\" | \"folders\" }): Promise<string[]> {\n        return (await this.findInfo(prefix, config)).map(x => x.path);\n    }\n    public async getURL(filePath: string): Promise<string> {\n        let { domain, port } = getStorageServerConfig();\n        return buildFileUrl(`https://${domain}:${port}/file/${encodeURIComponent(this.account)}/${encodeURIComponent(this.bucketName)}`, filePath);\n    }\n    public async getConfig(): Promise<ArchivesConfig> {\n        let bucket = await this.getBucket();\n        // Missing buckets say true, matching what they become once created (the default store type)\n        let progress = bucket?.store.getSyncProgress?.();\n        return {\n            supportsChangesAfter: !bucket || !!bucket.store.getChangesAfter,\n            remoteConfig: bucket?.routing,\n            index: progress?.index,\n            indexSources: progress?.sources,\n            readerDiskLimit: progress?.readerDiskLimit,\n            syncing: progress?.syncing,\n        };\n    }\n    public async hasWriteAccess(): Promise<boolean> {\n        return true;\n    }\n    public async getChangesAfter(time: number): Promise<ArchiveFileInfo[]> {\n        let bucket = await this.getBucket();\n        if (!bucket) return [];\n        if (!bucket.store.getChangesAfter) {\n            throw new Error(`Bucket ${this.account}/${this.bucketName} does not support getChangesAfter (rawDisk buckets have no index)`);\n        }\n        return await bucket.store.getChangesAfter(time);\n    }\n    public async getSyncStatus(): Promise<ArchivesSyncStatus> {\n        let bucket = await this.getBucket();\n        if (!bucket) return { allScansComplete: true, indexSize: 0, sources: [] };\n        if (!bucket.store.getSyncStatus) {\n            throw new Error(`Bucket ${this.account}/${this.bucketName} does not support getSyncStatus (rawDisk buckets have no synchronization)`);\n        }\n        return await bucket.store.getSyncStatus();\n    }\n}\n\nconst localArchives = new Map<string, IArchives>();\nexport function getLocalArchives(account: string, bucketName: string): IArchives {\n    let key = `${account}/${bucketName}`;\n    let existing = localArchives.get(key);\n    if (existing) return existing;\n    let archives = new ArchivesLocalBucket(account, bucketName);\n    localArchives.set(key, archives);\n    return archives;\n}\n"]}
+ /* _JS_SOURCE_HASH = "105df280a7bf3922f7699cdb68eeceac061da15a487b65e6e1652d9fdecf81e2"; */