sliftutils 1.7.70 → 1.7.72

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

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.computeStorePlan = exports.selectEntryAt = exports.findSelfIndexes = void 0;
+const misc_1 = require("socket-function/src/misc");
+const IArchives_1 = require("../IArchives");
+const remoteConfig_1 = require("./remoteConfig");
+const serverConfig_1 = require("./serverConfig");
+// Turns a bucket's routing config into this server's store plan: which of the entries are us, what stores (one per route) we run, and which peers each store synchronizes from.
+function findSelfIndexes(routing, account, bucketName) {
+    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.account !== account || parsed.bucketName !== bucketName)
+            continue;
+        if ((0, serverConfig_1.isOwnAddress)(parsed.address, parsed.port)) {
+            indexes.push(i);
+        }
+    }
+    return indexes;
+}
+exports.findSelfIndexes = findSelfIndexes;
+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;
+}
+exports.selectEntryAt = selectEntryAt;
+function mergeRoutes(routes) {
+    let list = routes.map(x => x || IArchives_1.FULL_ROUTE).map(x => [x[0], x[1]]);
+    (0, misc_1.sort)(list, x => x[0]);
+    let merged = [];
+    for (let route of list) {
+        let last = merged[merged.length - 1];
+        if (last && route[0] <= last[1]) {
+            last[1] = Math.max(last[1], route[1]);
+            continue;
+        }
+        merged.push(route);
+    }
+    return merged;
+}
+function summarizeSelf(selfEntries, now) {
+    var _a;
+    let current = selfEntries.filter(x => x.validWindow[0] <= now && now < x.validWindow[1]);
+    if (!current.length) {
+        let nearest = selectEntryAt(selfEntries, now);
+        current = nearest && [nearest] || [];
+    }
+    if (!current.length) {
+        return undefined;
+    }
+    return {
+        routes: mergeRoutes(current.map(x => x.route)),
+        public: current.some(x => x.public),
+        immutable: current.some(x => x.immutable),
+        noFullSync: current.some(x => x.noFullSync),
+        rawDisk: current.some(x => x.rawDisk),
+        readerDiskLimit: (_a = current.find(x => x.readerDiskLimit !== undefined)) === null || _a === void 0 ? void 0 : _a.readerDiskLimit,
+    };
+}
+function computeStorePlan(account, bucketName, routing) {
+    var _a;
+    let selfIndexes = findSelfIndexes(routing, account, bucketName);
+    let selfEntries = selfIndexes.map(i => routing.sources[i]);
+    let self = summarizeSelf(selfEntries, Date.now());
+    let ownIndexes = new Set(selfIndexes);
+    // One store per distinct route among ALL our entries - past and future windows included, so historical route folders keep serving their data and upcoming routes sync ahead of their window
+    let groups = new Map();
+    for (let i of selfIndexes) {
+        let entry = routing.sources[i];
+        let routeKey = JSON.stringify(entry.route || IArchives_1.FULL_ROUTE);
+        let group = groups.get(routeKey);
+        if (!group) {
+            group = { route: entry.route, entries: [], firstIndex: i };
+            groups.set(routeKey, group);
+        }
+        group.entries.push(entry);
+    }
+    let stores = [];
+    for (let [routeKey, group] of groups) {
+        let anchor = selectEntryAt(group.entries, Date.now());
+        let diskWindow = [0, 0];
+        if (anchor) {
+            let [start, end] = anchor.validWindow;
+            let merged = true;
+            while (merged) {
+                merged = false;
+                for (let entry of group.entries) {
+                    let [entryStart, entryEnd] = entry.validWindow;
+                    if (entryStart > end || entryEnd < start)
+                        continue;
+                    if (entryStart < start || entryEnd > end) {
+                        start = Math.min(start, entryStart);
+                        end = Math.max(end, entryEnd);
+                        merged = true;
+                    }
+                }
+            }
+            diskWindow = [start, end];
+        }
+        let sourceSpecs = [{ validWindow: diskWindow }];
+        let noFullSync = group.entries.some(x => x.noFullSync);
+        for (let i = group.firstIndex + 1; i < routing.sources.length; i++) {
+            let source = routing.sources[i];
+            if (typeof source === "string" || ownIndexes.has(i))
+                continue;
+            let sharedRoute = (0, remoteConfig_1.routeIntersection)(group.route, source.route);
+            if (!sharedRoute)
+                continue;
+            sourceSpecs.push({ sourceConfig: source, validWindow: source.validWindow, route: sharedRoute, noFullSync: source.noFullSync || noFullSync });
+        }
+        stores.push({
+            routeKey,
+            route: group.route,
+            entries: group.entries,
+            rawDisk: group.entries.some(x => x.rawDisk),
+            readerDiskLimit: (_a = group.entries.find(x => x.readerDiskLimit !== undefined)) === null || _a === void 0 ? void 0 : _a.readerDiskLimit,
+            sourceSpecs,
+        });
+    }
+    if (!stores.length) {
+        // Not in the config at all: still serve whatever the plain folder holds, through one inert full-route store
+        stores.push({ routeKey: JSON.stringify(IArchives_1.FULL_ROUTE), route: undefined, entries: [], rawDisk: false, readerDiskLimit: undefined, sourceSpecs: [{ validWindow: [0, 0] }] });
+    }
+    let structureKey = JSON.stringify(stores.map(s => ({ routeKey: s.routeKey, rawDisk: s.rawDisk, readerDiskLimit: s.readerDiskLimit })));
+    return { selfEntries, self, stores, structureKey };
+}
+exports.computeStorePlan = computeStorePlan;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"storePlan.js","sourceRoot":"","sources":["storePlan.ts"],"names":[],"mappings":"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","sourcesContent":["import { sort } from \"socket-function/src/misc\";\nimport { RemoteConfig, HostedConfig, SourceConfig, FULL_ROUTE } from \"../IArchives\";\nimport { parseHostedUrl, routeContains, routeIntersection } from \"./remoteConfig\";\nimport { isOwnAddress } from \"./serverConfig\";\n\n// Turns a bucket's routing config into this server's store plan: which of the entries are us, what stores (one per route) we run, and which peers each store synchronizes from.\n\nexport function findSelfIndexes(routing: RemoteConfig, account: string, bucketName: string): number[] {\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.account !== account || parsed.bucketName !== bucketName) continue;\n        if (isOwnAddress(parsed.address, parsed.port)) {\n            indexes.push(i);\n        }\n    }\n    return indexes;\n}\n\nexport function 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/** Our role in a bucket's routing config, summarized across ALL currently-valid self entries. Stored instead of a single representative HostedConfig, so nothing can accidentally use one entry's route or flags where the union is required - the standard config has the same URL twice: a routed write-shard entry plus an unrouted read-everything entry. */\nexport type SelfSummary = {\n    /** The union of the current entries' routes, with overlapping/adjacent ranges combined - which commonly collapses to a single full range, making matching trivial. */\n    routes: [number, number][];\n    public: boolean;\n    immutable: boolean;\n    noFullSync: boolean;\n    rawDisk: boolean;\n    readerDiskLimit?: number;\n};\n\nfunction mergeRoutes(routes: ([number, number] | undefined)[]): [number, number][] {\n    let list = routes.map(x => x || FULL_ROUTE).map(x => [x[0], x[1]] as [number, number]);\n    sort(list, x => x[0]);\n    let merged: [number, number][] = [];\n    for (let route of list) {\n        let last = merged[merged.length - 1];\n        if (last && route[0] <= last[1]) {\n            last[1] = Math.max(last[1], route[1]);\n            continue;\n        }\n        merged.push(route);\n    }\n    return merged;\n}\n\nfunction summarizeSelf(selfEntries: HostedConfig[], now: number): SelfSummary | undefined {\n    let current = selfEntries.filter(x => x.validWindow[0] <= now && now < x.validWindow[1]);\n    if (!current.length) {\n        let nearest = selectEntryAt(selfEntries, now);\n        current = nearest && [nearest] || [];\n    }\n    if (!current.length) {\n        return undefined;\n    }\n    return {\n        routes: mergeRoutes(current.map(x => x.route)),\n        public: current.some(x => x.public),\n        immutable: current.some(x => x.immutable),\n        noFullSync: current.some(x => x.noFullSync),\n        rawDisk: current.some(x => x.rawDisk),\n        readerDiskLimit: current.find(x => x.readerDiskLimit !== undefined)?.readerDiskLimit,\n    };\n}\n\nexport type StoreSourceSpec = { sourceConfig?: SourceConfig; validWindow: [number, number]; route?: [number, number]; noFullSync?: boolean };\nexport type StorePlanStore = {\n    routeKey: string;\n    route?: [number, number];\n    entries: HostedConfig[];\n    rawDisk: boolean;\n    readerDiskLimit?: number;\n    sourceSpecs: StoreSourceSpec[];\n};\nexport type StorePlan = {\n    selfEntries: HostedConfig[];\n    self: SelfSummary | undefined;\n    stores: StorePlanStore[];\n    structureKey: string;\n};\n\nexport function computeStorePlan(account: string, bucketName: string, routing: RemoteConfig): StorePlan {\n    let selfIndexes = findSelfIndexes(routing, account, bucketName);\n    let selfEntries = selfIndexes.map(i => routing.sources[i] as HostedConfig);\n    let self = summarizeSelf(selfEntries, Date.now());\n    let ownIndexes = new Set(selfIndexes);\n    // One store per distinct route among ALL our entries - past and future windows included, so historical route folders keep serving their data and upcoming routes sync ahead of their window\n    let groups = new Map<string, { route?: [number, number]; entries: HostedConfig[]; firstIndex: number }>();\n    for (let i of selfIndexes) {\n        let entry = routing.sources[i] as HostedConfig;\n        let routeKey = JSON.stringify(entry.route || FULL_ROUTE);\n        let group = groups.get(routeKey);\n        if (!group) {\n            group = { route: entry.route, entries: [], firstIndex: i };\n            groups.set(routeKey, group);\n        }\n        group.entries.push(entry);\n    }\n    let stores: StorePlanStore[] = [];\n    for (let [routeKey, group] of groups) {\n        let anchor = selectEntryAt(group.entries, Date.now());\n        let diskWindow: [number, number] = [0, 0];\n        if (anchor) {\n            let [start, end] = anchor.validWindow;\n            let merged = true;\n            while (merged) {\n                merged = false;\n                for (let entry of group.entries) {\n                    let [entryStart, entryEnd] = entry.validWindow;\n                    if (entryStart > end || entryEnd < start) continue;\n                    if (entryStart < start || entryEnd > end) {\n                        start = Math.min(start, entryStart);\n                        end = Math.max(end, entryEnd);\n                        merged = true;\n                    }\n                }\n            }\n            diskWindow = [start, end];\n        }\n        let sourceSpecs: StoreSourceSpec[] = [{ validWindow: diskWindow }];\n        let noFullSync = group.entries.some(x => x.noFullSync);\n        for (let i = group.firstIndex + 1; i < routing.sources.length; i++) {\n            let source = routing.sources[i];\n            if (typeof source === \"string\" || ownIndexes.has(i)) continue;\n            let sharedRoute = routeIntersection(group.route, source.route);\n            if (!sharedRoute) continue;\n            sourceSpecs.push({ sourceConfig: source, validWindow: source.validWindow, route: sharedRoute, noFullSync: source.noFullSync || noFullSync });\n        }\n        stores.push({\n            routeKey,\n            route: group.route,\n            entries: group.entries,\n            rawDisk: group.entries.some(x => x.rawDisk),\n            readerDiskLimit: group.entries.find(x => x.readerDiskLimit !== undefined)?.readerDiskLimit,\n            sourceSpecs,\n        });\n    }\n    if (!stores.length) {\n        // Not in the config at all: still serve whatever the plain folder holds, through one inert full-route store\n        stores.push({ routeKey: JSON.stringify(FULL_ROUTE), route: undefined, entries: [], rawDisk: false, readerDiskLimit: undefined, sourceSpecs: [{ validWindow: [0, 0] }] });\n    }\n    let structureKey = JSON.stringify(stores.map(s => ({ routeKey: s.routeKey, rawDisk: s.rawDisk, readerDiskLimit: s.readerDiskLimit })));\n    return { selfEntries, self, stores, structureKey };\n}\n"]}
+ /* _JS_SOURCE_HASH = "7971b00e29b1840ce5aa254d6b5e2b8db571965b03d2363c06aba914748aae66"; */

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.assertValidArgs = exports.assertValidPath = exports.assertValidName = void 0;
+function assertValidName(value, kind) {
+    if (!/^[\w-]{1,64}$/.test(value)) {
+        throw new Error(`Invalid ${kind} ${JSON.stringify(value)}, expected 1-64 characters of letters/numbers/underscore/dash`);
+    }
+}
+exports.assertValidName = assertValidName;
+function assertValidPath(path) {
+    if (Buffer.from(path, "utf8").length > 1000) {
+        throw new Error(`Path too long: ${path.length} characters > 1000. Path: ${path.slice(0, 200)}`);
+    }
+    if (!path || path.startsWith("/") || path.endsWith("/") || path.includes("//") || path.includes("\\") || path.includes("\x00")) {
+        throw new Error(`Invalid path ${JSON.stringify(path.slice(0, 200))}, paths cannot be empty, start or end with /, or contain //, backslashes, or null characters`);
+    }
+    if (path.split("/").some(part => part === "." || part === "..")) {
+        throw new Error(`Invalid path ${JSON.stringify(path.slice(0, 200))}, paths cannot contain . or .. segments`);
+    }
+}
+exports.assertValidPath = assertValidPath;
+/** Method decorator: validates the well-known fields of the method's single config-object argument - account/bucketName as names, path as a path - before the method runs. Fields the config doesn't have are skipped, so it applies to every API method uniformly. prefix is deliberately NOT validated: prefixes may be empty or end with "/", both invalid for paths. */
+function assertValidArgs(target, key, descriptor) {
+    let original = descriptor.value;
+    descriptor.value = function (...args) {
+        let config = args[0];
+        if (config && typeof config === "object") {
+            if ("account" in config)
+                assertValidName(config.account, "account");
+            if ("bucketName" in config)
+                assertValidName(config.bucketName, "bucket name");
+            if ("path" in config)
+                assertValidPath(config.path);
+        }
+        return original.apply(this, args);
+    };
+}
+exports.assertValidArgs = assertValidArgs;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsaWRhdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbInZhbGlkYXRpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsU0FBZ0IsZUFBZSxDQUFDLEtBQWEsRUFBRSxJQUFZO0lBQ3ZELElBQUksQ0FBQyxlQUFlLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxFQUFFLENBQUM7UUFDL0IsTUFBTSxJQUFJLEtBQUssQ0FBQyxXQUFXLElBQUksSUFBSSxJQUFJLENBQUMsU0FBUyxDQUFDLEtBQUssQ0FBQywrREFBK0QsQ0FBQyxDQUFDO0lBQzdILENBQUM7QUFDTCxDQUFDO0FBSkQsMENBSUM7QUFFRCxTQUFnQixlQUFlLENBQUMsSUFBWTtJQUN4QyxJQUFJLE1BQU0sQ0FBQyxJQUFJLENBQUMsSUFBSSxFQUFFLE1BQU0sQ0FBQyxDQUFDLE1BQU0sR0FBRyxJQUFJLEVBQUUsQ0FBQztRQUMxQyxNQUFNLElBQUksS0FBSyxDQUFDLGtCQUFrQixJQUFJLENBQUMsTUFBTSw2QkFBNkIsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDLEVBQUUsR0FBRyxDQUFDLEVBQUUsQ0FBQyxDQUFDO0lBQ3BHLENBQUM7SUFDRCxJQUFJLENBQUMsSUFBSSxJQUFJLElBQUksQ0FBQyxVQUFVLENBQUMsR0FBRyxDQUFDLElBQUksSUFBSSxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsSUFBSSxJQUFJLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxJQUFJLElBQUksQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLElBQUksSUFBSSxDQUFDLFFBQVEsQ0FBQyxNQUFNLENBQUMsRUFBRSxDQUFDO1FBQzdILE1BQU0sSUFBSSxLQUFLLENBQUMsZ0JBQWdCLElBQUksQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDLEVBQUUsR0FBRyxDQUFDLENBQUMsOEZBQThGLENBQUMsQ0FBQztJQUN0SyxDQUFDO0lBQ0QsSUFBSSxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLElBQUksS0FBSyxHQUFHLElBQUksSUFBSSxLQUFLLElBQUksQ0FBQyxFQUFFLENBQUM7UUFDOUQsTUFBTSxJQUFJLEtBQUssQ0FBQyxnQkFBZ0IsSUFBSSxDQUFDLFNBQVMsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLENBQUMsRUFBRSxHQUFHLENBQUMsQ0FBQyx5Q0FBeUMsQ0FBQyxDQUFDO0lBQ2pILENBQUM7QUFDTCxDQUFDO0FBVkQsMENBVUM7QUFFRCw0V0FBNFc7QUFDNVcsU0FBZ0IsZUFBZSxDQUFDLE1BQWUsRUFBRSxHQUFXLEVBQUUsVUFBOEI7SUFDeEYsSUFBSSxRQUFRLEdBQUcsVUFBVSxDQUFDLEtBQXdDLENBQUM7SUFDbkUsVUFBVSxDQUFDLEtBQUssR0FBRyxVQUFVLEdBQUcsSUFBZTtRQUMzQyxJQUFJLE1BQU0sR0FBRyxJQUFJLENBQUMsQ0FBQyxDQUF5RSxDQUFDO1FBQzdGLElBQUksTUFBTSxJQUFJLE9BQU8sTUFBTSxLQUFLLFFBQVEsRUFBRSxDQUFDO1lBQ3ZDLElBQUksU0FBUyxJQUFJLE1BQU07Z0JBQUUsZUFBZSxDQUFDLE1BQU0sQ0FBQyxPQUFpQixFQUFFLFNBQVMsQ0FBQyxDQUFDO1lBQzlFLElBQUksWUFBWSxJQUFJLE1BQU07Z0JBQUUsZUFBZSxDQUFDLE1BQU0sQ0FBQyxVQUFvQixFQUFFLGFBQWEsQ0FBQyxDQUFDO1lBQ3hGLElBQUksTUFBTSxJQUFJLE1BQU07Z0JBQUUsZUFBZSxDQUFDLE1BQU0sQ0FBQyxJQUFjLENBQUMsQ0FBQztRQUNqRSxDQUFDO1FBQ0QsT0FBTyxRQUFRLENBQUMsS0FBSyxDQUFDLElBQUksRUFBRSxJQUFJLENBQUMsQ0FBQztJQUN0QyxDQUFDLENBQUM7QUFDTixDQUFDO0FBWEQsMENBV0MiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZnVuY3Rpb24gYXNzZXJ0VmFsaWROYW1lKHZhbHVlOiBzdHJpbmcsIGtpbmQ6IHN0cmluZyk6IHZvaWQge1xuICAgIGlmICghL15bXFx3LV17MSw2NH0kLy50ZXN0KHZhbHVlKSkge1xuICAgICAgICB0aHJvdyBuZXcgRXJyb3IoYEludmFsaWQgJHtraW5kfSAke0pTT04uc3RyaW5naWZ5KHZhbHVlKX0sIGV4cGVjdGVkIDEtNjQgY2hhcmFjdGVycyBvZiBsZXR0ZXJzL251bWJlcnMvdW5kZXJzY29yZS9kYXNoYCk7XG4gICAgfVxufVxuXG5leHBvcnQgZnVuY3Rpb24gYXNzZXJ0VmFsaWRQYXRoKHBhdGg6IHN0cmluZyk6IHZvaWQge1xuICAgIGlmIChCdWZmZXIuZnJvbShwYXRoLCBcInV0ZjhcIikubGVuZ3RoID4gMTAwMCkge1xuICAgICAgICB0aHJvdyBuZXcgRXJyb3IoYFBhdGggdG9vIGxvbmc6ICR7cGF0aC5sZW5ndGh9IGNoYXJhY3RlcnMgPiAxMDAwLiBQYXRoOiAke3BhdGguc2xpY2UoMCwgMjAwKX1gKTtcbiAgICB9XG4gICAgaWYgKCFwYXRoIHx8IHBhdGguc3RhcnRzV2l0aChcIi9cIikgfHwgcGF0aC5lbmRzV2l0aChcIi9cIikgfHwgcGF0aC5pbmNsdWRlcyhcIi8vXCIpIHx8IHBhdGguaW5jbHVkZXMoXCJcXFxcXCIpIHx8IHBhdGguaW5jbHVkZXMoXCJcXHgwMFwiKSkge1xuICAgICAgICB0aHJvdyBuZXcgRXJyb3IoYEludmFsaWQgcGF0aCAke0pTT04uc3RyaW5naWZ5KHBhdGguc2xpY2UoMCwgMjAwKSl9LCBwYXRocyBjYW5ub3QgYmUgZW1wdHksIHN0YXJ0IG9yIGVuZCB3aXRoIC8sIG9yIGNvbnRhaW4gLy8sIGJhY2tzbGFzaGVzLCBvciBudWxsIGNoYXJhY3RlcnNgKTtcbiAgICB9XG4gICAgaWYgKHBhdGguc3BsaXQoXCIvXCIpLnNvbWUocGFydCA9PiBwYXJ0ID09PSBcIi5cIiB8fCBwYXJ0ID09PSBcIi4uXCIpKSB7XG4gICAgICAgIHRocm93IG5ldyBFcnJvcihgSW52YWxpZCBwYXRoICR7SlNPTi5zdHJpbmdpZnkocGF0aC5zbGljZSgwLCAyMDApKX0sIHBhdGhzIGNhbm5vdCBjb250YWluIC4gb3IgLi4gc2VnbWVudHNgKTtcbiAgICB9XG59XG5cbi8qKiBNZXRob2QgZGVjb3JhdG9yOiB2YWxpZGF0ZXMgdGhlIHdlbGwta25vd24gZmllbGRzIG9mIHRoZSBtZXRob2QncyBzaW5nbGUgY29uZmlnLW9iamVjdCBhcmd1bWVudCAtIGFjY291bnQvYnVja2V0TmFtZSBhcyBuYW1lcywgcGF0aCBhcyBhIHBhdGggLSBiZWZvcmUgdGhlIG1ldGhvZCBydW5zLiBGaWVsZHMgdGhlIGNvbmZpZyBkb2Vzbid0IGhhdmUgYXJlIHNraXBwZWQsIHNvIGl0IGFwcGxpZXMgdG8gZXZlcnkgQVBJIG1ldGhvZCB1bmlmb3JtbHkuIHByZWZpeCBpcyBkZWxpYmVyYXRlbHkgTk9UIHZhbGlkYXRlZDogcHJlZml4ZXMgbWF5IGJlIGVtcHR5IG9yIGVuZCB3aXRoIFwiL1wiLCBib3RoIGludmFsaWQgZm9yIHBhdGhzLiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGFzc2VydFZhbGlkQXJncyh0YXJnZXQ6IHVua25vd24sIGtleTogc3RyaW5nLCBkZXNjcmlwdG9yOiBQcm9wZXJ0eURlc2NyaXB0b3IpOiB2b2lkIHtcbiAgICBsZXQgb3JpZ2luYWwgPSBkZXNjcmlwdG9yLnZhbHVlIGFzICguLi5hcmdzOiB1bmtub3duW10pID0+IHVua25vd247XG4gICAgZGVzY3JpcHRvci52YWx1ZSA9IGZ1bmN0aW9uICguLi5hcmdzOiB1bmtub3duW10pOiB1bmtub3duIHtcbiAgICAgICAgbGV0IGNvbmZpZyA9IGFyZ3NbMF0gYXMgeyBhY2NvdW50Pzogc3RyaW5nOyBidWNrZXROYW1lPzogc3RyaW5nOyBwYXRoPzogc3RyaW5nIH0gfCB1bmRlZmluZWQ7XG4gICAgICAgIGlmIChjb25maWcgJiYgdHlwZW9mIGNvbmZpZyA9PT0gXCJvYmplY3RcIikge1xuICAgICAgICAgICAgaWYgKFwiYWNjb3VudFwiIGluIGNvbmZpZykgYXNzZXJ0VmFsaWROYW1lKGNvbmZpZy5hY2NvdW50IGFzIHN0cmluZywgXCJhY2NvdW50XCIpO1xuICAgICAgICAgICAgaWYgKFwiYnVja2V0TmFtZVwiIGluIGNvbmZpZykgYXNzZXJ0VmFsaWROYW1lKGNvbmZpZy5idWNrZXROYW1lIGFzIHN0cmluZywgXCJidWNrZXQgbmFtZVwiKTtcbiAgICAgICAgICAgIGlmIChcInBhdGhcIiBpbiBjb25maWcpIGFzc2VydFZhbGlkUGF0aChjb25maWcucGF0aCBhcyBzdHJpbmcpO1xuICAgICAgICB9XG4gICAgICAgIHJldHVybiBvcmlnaW5hbC5hcHBseSh0aGlzLCBhcmdzKTtcbiAgICB9O1xufVxuIl19
+ /* _JS_SOURCE_HASH = "86f30936cf7059feaf31e421a3bf6a44c9adc86e104f6cbadcc59d1b90114c7f"; */

package/storage/remoteStorage/grantAccessCli.ts

@@ -14,7 +14,7 @@ async function main() {
     let { address, port } = parseStorageUrl(url);
     let nodeId = SocketFunction.connect({ address, port });
     await authenticateStorage({ address, port, nodeId });
-    let record = await RemoteStorageController.nodes[nodeId].adminGrantAccess(requestId);
+    let record = await RemoteStorageController.nodes[nodeId].adminGrantAccess({ requestId });
     console.log(`Granted machine ${record.machineId} access to account ${JSON.stringify(record.account)}`);
     process.exit(0);
 }

package/storage/remoteStorage/intermediateSources.d.ts

@@ -1,9 +1,8 @@
-import { RemoteConfig, HostedConfig, BackblazeConfig } from "../IArchives";
+import { RemoteConfig, SourceConfig } from "../IArchives";
 export declare const INTERMEDIATE_EXPIRE_GRACE: number;
 /** Adding or removing intermediates is a real config update, so it takes a real version increment - but a proportional one, so it stays far below whatever the author's next version would be (whether they count 1, 2, 3 or use timestamps), and a million of them still fit under it. */
 export declare function nextIntermediateVersion(version: number): number;
-type ObjectSource = HostedConfig | BackblazeConfig;
-export declare function getIntermediateSources(config: RemoteConfig): ObjectSource[];
+export declare function getIntermediateSources(config: RemoteConfig): SourceConfig[];
 export declare function hasIntermediateSources(config: RemoteConfig): boolean;
 /** Removes every intermediate entry and rejoins the windows it split, giving back the underlying configuration. Two configs that resolve equal differ only by intermediates. */
 export declare function resolveIntermediateSources(config: RemoteConfig): RemoteConfig;
@@ -17,5 +16,4 @@ export declare function injectIntermediateSource(config: RemoteConfig, inject: {
 /** Intermediates whose window ended more than INTERMEDIATE_EXPIRE_GRACE ago are removed, and the windows they split are rejoined. */
 export declare function expireIntermediateSources(config: RemoteConfig, now: number): RemoteConfig;
 /** The url of the entry an intermediate was split out of - the neighbour it touches. */
-export declare function findSplitUrl(config: RemoteConfig, intermediate: ObjectSource): string | undefined;
-export {};
+export declare function findSplitUrl(config: RemoteConfig, intermediate: SourceConfig): string | undefined;

package/storage/remoteStorage/intermediateSources.ts

@@ -1,4 +1,4 @@
-import { RemoteConfig, RemoteConfigBase, HostedConfig, BackblazeConfig } from "../IArchives";
+import { RemoteConfig, RemoteConfigBase, SourceConfig } from "../IArchives";
 
 export const INTERMEDIATE_EXPIRE_GRACE = 15 * 60 * 1000;
 const INTERMEDIATE_VERSION_FRACTION = 1_000_000;
@@ -12,38 +12,36 @@ export function nextIntermediateVersion(version: number): number {
     return version + step;
 }
 
-type ObjectSource = HostedConfig | BackblazeConfig;
-
-function isObjectSource(source: RemoteConfigBase): source is ObjectSource {
+function isSourceConfig(source: RemoteConfigBase): source is SourceConfig {
     return typeof source !== "string";
 }
 
 function cloneSource(source: RemoteConfigBase): RemoteConfigBase {
-    if (!isObjectSource(source)) return source;
+    if (!isSourceConfig(source)) return source;
     return { ...source, validWindow: [source.validWindow[0], source.validWindow[1]] };
 }
 
-function joinKey(source: ObjectSource): string {
+function joinKey(source: SourceConfig): string {
     return JSON.stringify({ ...source, validWindow: undefined });
 }
 
-export function getIntermediateSources(config: RemoteConfig): ObjectSource[] {
-    return config.sources.filter(x => isObjectSource(x) && x.intermediate) as ObjectSource[];
+export function getIntermediateSources(config: RemoteConfig): SourceConfig[] {
+    return config.sources.filter(x => isSourceConfig(x) && x.intermediate) as SourceConfig[];
 }
 
 export function hasIntermediateSources(config: RemoteConfig): boolean {
-    return config.sources.some(x => isObjectSource(x) && x.intermediate);
+    return config.sources.some(x => isSourceConfig(x) && x.intermediate);
 }
 
 /** Removes every intermediate entry and rejoins the windows it split, giving back the underlying configuration. Two configs that resolve equal differ only by intermediates. */
 export function resolveIntermediateSources(config: RemoteConfig): RemoteConfig {
     if (!hasIntermediateSources(config)) return config;
     let removed = getIntermediateSources(config);
-    let sources = config.sources.filter(x => !isObjectSource(x) || !x.intermediate).map(cloneSource);
+    let sources = config.sources.filter(x => !isSourceConfig(x) || !x.intermediate).map(cloneSource);
     for (let gap of removed) {
         let [gapStart, gapEnd] = gap.validWindow;
-        let before = sources.find(x => isObjectSource(x) && x.validWindow[1] === gapStart) as ObjectSource | undefined;
-        let after = sources.find(x => isObjectSource(x) && x.validWindow[0] === gapEnd) as ObjectSource | undefined;
+        let before = sources.find(x => isSourceConfig(x) && x.validWindow[1] === gapStart) as SourceConfig | undefined;
+        let after = sources.find(x => isSourceConfig(x) && x.validWindow[0] === gapEnd) as SourceConfig | undefined;
         if (before && after && joinKey(before) === joinKey(after)) {
             before.validWindow = [before.validWindow[0], after.validWindow[1]];
             sources.splice(sources.indexOf(after), 1);
@@ -64,12 +62,12 @@ export function resolveIntermediateSources(config: RemoteConfig): RemoteConfig {
 export function injectIntermediateSource(config: RemoteConfig, inject: { splitUrl: string; intermediateUrl: string; start: number; end: number }): RemoteConfig {
     let { splitUrl, intermediateUrl, start, end } = inject;
     if (start >= end) return config;
-    if (config.sources.some(x => isObjectSource(x) && x.intermediate && x.url === intermediateUrl && x.validWindow[0] === start && x.validWindow[1] === end)) {
+    if (config.sources.some(x => isSourceConfig(x) && x.intermediate && x.url === intermediateUrl && x.validWindow[0] === start && x.validWindow[1] === end)) {
         return config;
     }
     let sources: RemoteConfigBase[] = [];
     for (let source of config.sources) {
-        if (!isObjectSource(source) || source.url !== splitUrl || source.intermediate) {
+        if (!isSourceConfig(source) || source.url !== splitUrl || source.intermediate) {
             sources.push(cloneSource(source));
             continue;
         }
@@ -110,8 +108,8 @@ export function expireIntermediateSources(config: RemoteConfig, now: number): Re
 }
 
 /** The url of the entry an intermediate was split out of - the neighbour it touches. */
-export function findSplitUrl(config: RemoteConfig, intermediate: ObjectSource): string | undefined {
+export function findSplitUrl(config: RemoteConfig, intermediate: SourceConfig): string | undefined {
     let [start, end] = intermediate.validWindow;
-    let neighbour = config.sources.find(x => isObjectSource(x) && !x.intermediate && (x.validWindow[1] === start || x.validWindow[0] === end)) as ObjectSource | undefined;
+    let neighbour = config.sources.find(x => isSourceConfig(x) && !x.intermediate && (x.validWindow[1] === start || x.validWindow[0] === end)) as SourceConfig | undefined;
     return neighbour?.url;
 }

package/storage/remoteStorage/remoteConfig.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 /// <reference types="node" />
-import { RemoteConfig, RemoteConfigBase, HostedConfig, BackblazeConfig, ArchiveFileInfo, ChangesAfterConfig } from "../IArchives";
+import { RemoteConfig, RemoteConfigBase, SourceConfig, ArchiveFileInfo, ChangesAfterConfig } from "../IArchives";
 export declare const ROUTING_FILE = "storage/storagerouting.json";
 /** The variable-shard route override embedded in the key ("<sentinel>_<value>", see VARIABLE_SHARD), or undefined when the key has no sentinel or the sentinel has no value yet. */
 export declare function parseVariableRoute(key: string): number | undefined;
@@ -26,7 +26,7 @@ export declare function parseBackblazeUrl(url: string): {
     bucketName: string;
 };
 export declare function replaceHostedUrlPort(url: string, port: number): string;
-export declare function normalizeSource(source: RemoteConfigBase): HostedConfig | BackblazeConfig;
+export declare function normalizeSource(source: RemoteConfigBase): SourceConfig;
 export declare function normalizeRemoteConfig(config: RemoteConfig | RemoteConfigBase): RemoteConfig;
 export declare function parseRoutingData(data: Buffer): RemoteConfig;
 export declare function serializeRemoteConfig(config: RemoteConfig): Buffer;

package/storage/remoteStorage/remoteConfig.ts

@@ -2,7 +2,7 @@ import { sort } from "socket-function/src/misc";
 import { getBufferInt } from "socket-function/src/bits";
 import { setFlag } from "socket-function/require/compileFlags";
 import jsSha256 from "js-sha256";
-import { RemoteConfig, RemoteConfigBase, HostedConfig, BackblazeConfig, ArchiveFileInfo, ChangesAfterConfig, FULL_VALID_WINDOW, FULL_ROUTE, VARIABLE_SHARD } from "../IArchives";
+import { RemoteConfig, RemoteConfigBase, SourceConfig, ArchiveFileInfo, ChangesAfterConfig, FULL_VALID_WINDOW, FULL_ROUTE, VARIABLE_SHARD } from "../IArchives";
 
 setFlag(require, "js-sha256", "allowclient", true);
 
@@ -109,7 +109,7 @@ export function replaceHostedUrlPort(url: string, port: number): string {
     return u.toString();
 }
 
-export function normalizeSource(source: RemoteConfigBase): HostedConfig | BackblazeConfig {
+export function normalizeSource(source: RemoteConfigBase): SourceConfig {
     if (typeof source !== "string") {
         let window = source.validWindow;
         if (!Array.isArray(window) || window.length !== 2 || !window.every(x => typeof x === "number")) {
@@ -144,7 +144,7 @@ export function normalizeSource(source: RemoteConfigBase): HostedConfig | Backbl
 }
 
 /** How far up from 0 the sources' routes reach without a gap (1 means the whole key space). */
-function getRouteCoverage(sources: (HostedConfig | BackblazeConfig)[]): number {
+function getRouteCoverage(sources: SourceConfig[]): number {
     let routes = sources.map(x => x.route || FULL_ROUTE);
     sort(routes, x => x[0]);
     let covered = 0;
@@ -204,9 +204,25 @@ export function normalizeRemoteConfig(config: RemoteConfig | RemoteConfigBase):
         groupEnd = Math.max(groupEnd, source.validWindow[1]);
     }
     checkGroup();
+    // Two entries with the EXACT same URL and the SAME route may never be valid at the same time: on that server the route maps to exactly one on-disk folder and one store, so simultaneous duplicates would collide on it. A different port is a different server. Non-overlapping windows are fine; that is how transitions between windows work.
+    for (let i = 0; i < sources.length; i++) {
+        for (let j = i + 1; j < sources.length; j++) {
+            let a = sources[i];
+            let b = sources[j];
+            if (sourceRouteIdentity(a) !== sourceRouteIdentity(b)) continue;
+            if (a.validWindow[0] < b.validWindow[1] && b.validWindow[0] < a.validWindow[1]) {
+                throw new Error(`Two sources with the same URL have the same route with overlapping valid windows - on that server the route maps to one on-disk folder, so these would collide. Give same-route entries non-overlapping windows instead. Conflicting: ${JSON.stringify(a)} and ${JSON.stringify(b)}`);
+            }
+        }
+    }
     return result;
 }
 
+/** The per-store identity of a source: its exact URL plus its route. Entries sharing this identity map to the same store/folder on the same server, so they may never overlap in time (see normalizeRemoteConfig). */
+function sourceRouteIdentity(source: SourceConfig): string {
+    return `${source.url}|${JSON.stringify(source.route || FULL_ROUTE)}`;
+}
+
 export function parseRoutingData(data: Buffer): RemoteConfig {
     let text = data.toString();
     let parsed: RemoteConfig;

package/storage/remoteStorage/serverConfig.d.ts

@@ -0,0 +1,27 @@
+import type { IStorage } from "../IStorage";
+import type { AccessRequest, TrustRecord } from "./storageController";
+export type StorageServerConfig = {
+    domain: string;
+    port: number;
+    rootDomain: string;
+    sshTarget: string;
+    serverCommand: string;
+    folder: string;
+};
+export declare function setStorageServerConfig(value: StorageServerConfig): void;
+export declare function getStorageServerConfig(): StorageServerConfig;
+export declare function getStorageServerConfigOptional(): StorageServerConfig | undefined;
+export declare function setWritesRejectedReason(reason: string | undefined): void;
+export declare function getWritesRejectedReason(): string | undefined;
+export declare function assertWritesAllowed(): void;
+export declare function getStorageFolder(): string;
+export declare function getTrust(): Promise<IStorage<TrustRecord>>;
+export declare function getRequests(): Promise<IStorage<AccessRequest[]>>;
+export declare function setTrustedMachines(config: {
+    account: string;
+    machineIds: string[];
+}): Promise<void>;
+export declare function addExtraListenPort(port: number): void;
+export declare function removeExtraListenPort(port: number): void;
+/** Whether address:port is this server process. The ONE self test - findSelfIndexes, createApiArchives, and SourceWrapper all consult it, so "is this me" cannot disagree between the routing plan and connection building: a URL that is us on an extra listen port must never become a network client to ourselves, which is how infinite self-request loops form. */
+export declare function isOwnAddress(address: string, port: number): boolean;

package/storage/remoteStorage/serverConfig.ts

@@ -0,0 +1,109 @@
+import path from "path";
+import { getFileStorageNested2 } from "../FileFolderAPI";
+import { TransactionStorage } from "../TransactionStorage";
+import { JSONStorage } from "../JSONStorage";
+import type { IStorage } from "../IStorage";
+import type { AccessRequest, TrustRecord } from "./storageController";
+import { getArg } from "./cliArgs";
+
+// The storage server's process-level identity and system state: which server we are (config, extra ports), whether writes are allowed, and the trust/request stores.
+
+export type StorageServerConfig = {
+    domain: string;
+    port: number;
+    rootDomain: string;
+    sshTarget: string;
+    serverCommand: string;
+    folder: string;
+};
+
+let config: StorageServerConfig | undefined;
+export function setStorageServerConfig(value: StorageServerConfig): void {
+    config = value;
+}
+export function getStorageServerConfig(): StorageServerConfig {
+    if (!config) {
+        throw new Error(`Storage server is not initialized (this API only works on the storage server)`);
+    }
+    return config;
+}
+export function getStorageServerConfigOptional(): StorageServerConfig | undefined {
+    return config;
+}
+
+let writesRejectedReason: string | undefined;
+export function setWritesRejectedReason(reason: string | undefined): void {
+    writesRejectedReason = reason;
+}
+export function getWritesRejectedReason(): string | undefined {
+    return writesRejectedReason;
+}
+export function assertWritesAllowed(): void {
+    if (writesRejectedReason) throw new Error(writesRejectedReason);
+}
+
+export function getStorageFolder(): string {
+    let config = getStorageServerConfigOptional();
+    if (config) return config.folder;
+    let folder = 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.resolve(folder);
+}
+
+const systemStorages = new Map<string, Promise<IStorage<unknown>>>();
+function getSystemStorage<T>(name: string): Promise<IStorage<T>> {
+    let storage = systemStorages.get(name);
+    if (!storage) {
+        storage = (async () => {
+            let root = await getFileStorageNested2(getStorageFolder());
+            let system = await root.folder.getStorage("system2");
+            let transactionName = "storage" + name[0].toUpperCase() + name.slice(1);
+            return new JSONStorage<unknown>(new TransactionStorage(await system.folder.getStorage(name), transactionName));
+        })();
+        systemStorages.set(name, storage);
+    }
+    return storage as Promise<IStorage<T>>;
+}
+export function getTrust(): Promise<IStorage<TrustRecord>> {
+    return getSystemStorage<TrustRecord>("trust");
+}
+export function getRequests(): Promise<IStorage<AccessRequest[]>> {
+    return getSystemStorage<AccessRequest[]>("requests");
+}
+
+export async function setTrustedMachines(config: { account: string; machineIds: string[] }): Promise<void> {
+    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() });
+    }
+}
+
+const extraListenPorts = new Set<number>();
+export function addExtraListenPort(port: number): void {
+    extraListenPorts.add(port);
+}
+export function removeExtraListenPort(port: number): void {
+    extraListenPorts.delete(port);
+}
+/** Whether address:port is this server process. The ONE self test - findSelfIndexes, createApiArchives, and SourceWrapper all consult it, so "is this me" cannot disagree between the routing plan and connection building: a URL that is us on an extra listen port must never become a network client to ourselves, which is how infinite self-request loops form. */
+export function isOwnAddress(address: string, port: number): boolean {
+    let config = getStorageServerConfigOptional();
+    if (!config) return false;
+    if (address !== config.domain) return false;
+    return port === config.port || extraListenPorts.has(port);
+}

package/storage/remoteStorage/sourceWrapper.d.ts

@@ -1,10 +1,10 @@
-import { IArchives, HostedConfig, BackblazeConfig, RemoteConfig } from "../IArchives";
+import { IArchives, SourceConfig, RemoteConfig } from "../IArchives";
 import { ArchivesUrl } from "./ArchivesUrl";
 export declare const RETRY_START_DELAY: number;
 export declare const RETRY_MAX_DELAY: number;
 export declare const RETRY_GROWTH = 1.5;
 export declare class SourceWrapper {
-    config: HostedConfig | BackblazeConfig;
+    config: SourceConfig;
     private background;
     api?: IArchives;
     url?: ArchivesUrl;
@@ -16,7 +16,7 @@ export declare class SourceWrapper {
     private constructor();
     /** Config updates routinely just move a source's valid window (the last window extends forever, then gets reduced when a new entry is appended). The wrapper survives that: only the window changes, keeping the connection, pings, and latency history. */
     updateValidWindow(validWindow: [number, number]): void;
-    static create(config: HostedConfig | BackblazeConfig, options?: {
+    static create(config: SourceConfig, options?: {
         background?: boolean;
         readOnly?: boolean;
     }): Promise<SourceWrapper>;

package/storage/remoteStorage/sourceWrapper.ts

@@ -1,12 +1,13 @@
 import { isNode, sort } from "socket-function/src/misc";
 import { delay } from "socket-function/src/batching";
 import { getSecret } from "../../misc/getSecret";
-import { IArchives, HostedConfig, BackblazeConfig, RemoteConfig } from "../IArchives";
+import { IArchives, SourceConfig, RemoteConfig } from "../IArchives";
 import { ROUTING_FILE, getBucketBaseUrl, parseHostedUrl, parseBackblazeUrl, parseRoutingData } from "./remoteConfig";
 import { ArchivesRemote } from "./ArchivesRemote";
 import { ArchivesUrl } from "./ArchivesUrl";
 import { ArchivesBackblaze } from "../backblaze";
-import { getLocalArchives, isOwnAddress } from "./storageServerState";
+import { isOwnAddress } from "./serverConfig";
+import { getLocalArchives } from "./storageServerState";
 
 export const RETRY_START_DELAY = 2 * 1000;
 export const RETRY_MAX_DELAY = 5 * 60 * 1000;
@@ -40,7 +41,7 @@ export class SourceWrapper {
     private accessCache?: { hasAccess: boolean; time: number };
 
     private constructor(
-        public config: HostedConfig | BackblazeConfig,
+        public config: SourceConfig,
         // false for short-lived probe instances, which must never leave a retry loop behind
         private background: boolean,
     ) { }
@@ -53,7 +54,7 @@ export class SourceWrapper {
         this.config.validWindow = validWindow;
     }
 
-    public static async create(config: HostedConfig | BackblazeConfig, options?: { background?: boolean; readOnly?: boolean }): Promise<SourceWrapper> {
+    public static async create(config: SourceConfig, options?: { background?: boolean; readOnly?: boolean }): Promise<SourceWrapper> {
         let wrapper = new SourceWrapper(config, options?.background !== false);
         // A public bucket serves everything we can read over plain HTTPS GETs, so there is no reason to open an API connection (which costs a WebSocket, and an access grant we likely don't have) just to read it
         if (options?.readOnly && config.public !== false) {
@@ -77,10 +78,10 @@ export class SourceWrapper {
         let parsed = parseHostedUrl(config.url);
         if (isNode() && isOwnAddress(parsed.address, parsed.port)) {
             // A bucket hosted by our own process - use it directly instead of calling ourselves
-            wrapper.api = getLocalArchives(parsed.account, parsed.bucketName);
+            wrapper.api = getLocalArchives(parsed.account, parsed.bucketName, config);
             return wrapper;
         }
-        wrapper.remote = new ArchivesRemote({ url: config.url, waitForAccess: false });
+        wrapper.remote = new ArchivesRemote({ url: config.url, waitForAccess: false, sourceConfig: config });
         wrapper.api = wrapper.remote;
         if (config.public !== false) {
             wrapper.url = new ArchivesUrl(getBucketBaseUrl(config.url));