sliftutils 1.7.138 → 1.7.140

package/storage/remoteStorage/createArchives.ts

@@ -83,7 +83,7 @@ function coverRoutes(candidates: SourceWrapper[]): SourceWrapper[] | undefined {
     return chosen;
 }
 
-/** READS ONLY. Drops sources that recently failed while disconnected - unless that would leave nothing, in which case a down source is still better than no source, and we retry it immediately. Never applies to writes (or noFallbacks reads of the write target): the write node is strictly the FIRST source matching the route and valid window, regardless of connectivity - a client's flaky view of the network must never scatter writes across the chain (spec: client writes are consistent, client reads are redundant). */
+/** READS ONLY. Drops sources that recently failed while disconnected - unless that would leave nothing, in which case a down source is still better than no source, and we retry it immediately. Never applies to writes (or fallbacks:false reads of the write target): the write node is strictly the FIRST source matching the route and valid window, regardless of connectivity - a client's flaky view of the network must never scatter writes across the chain (spec: client writes are consistent, client reads are redundant). */
 function preferUsable(sources: SourceWrapper[]): SourceWrapper[] {
     let usable = sources.filter(x => !x.isOnCooldown());
     return usable.length && usable || sources;
@@ -106,12 +106,12 @@ export class ArchivesChain implements IArchives {
         return `chain ${urls.join(", ")}`;
     }
 
-    // The ONE dispatch for every operation: no fallbacks (all writes by default, and noFallbacks reads) -> the primary node only, via runPrimary; everything else -> the shared fallback loop, trying sources in config order (or latency order for fast reads) and only moving on when one fails. Writes in the loop differ from reads only in calling source.write.
-    private async run<T>(state: ChainState, config: { apiOnly?: boolean; write?: boolean; route?: number; noFallbacks?: boolean; fallbacks?: boolean; retries?: number; fast?: boolean; timeout?: SmartTimeout }, run: (archives: IArchives, sourceUrl: string) => Promise<T>): Promise<T> {
-        if (config.fast && config.noFallbacks) {
-            throw new Error(`fast and noFallbacks are mutually exclusive for ${this.getDebugName()}: noFallbacks only considers one source (the write node), so there is no order to speed up`);
+    // The ONE dispatch for every operation, on ONE flag: fallbacks false -> the primary node only, via runPrimary; fallbacks true -> the shared fallback loop, trying sources in config order (or latency order for fast reads) and moving on whenever one fails. Every caller sets fallbacks unconditionally - reads turn it on unless the caller said noFallbacks, writes turn it off unless the caller said fallbacks. Writes in the loop differ from reads only in calling source.write.
+    private async run<T>(state: ChainState, config: { fallbacks: boolean; apiOnly?: boolean; write?: boolean; route?: number; retries?: number; fast?: boolean; timeout?: SmartTimeout }, run: (archives: IArchives, sourceUrl: string) => Promise<T>): Promise<T> {
+        if (config.fast && !config.fallbacks) {
+            throw new Error(`fast requires fallbacks for ${this.getDebugName()}: without fallbacks only one source (the write node) is considered, so there is no order to speed up`);
         }
-        if (config.noFallbacks || config.write && !config.fallbacks) {
+        if (!config.fallbacks) {
             return await this.runPrimary(config, run);
         }
         let retries = config.retries;
@@ -163,16 +163,11 @@ export class ArchivesChain implements IArchives {
                         await this.prepareWrongTargetRetry(state, message.includes(STORAGE_WRONG_VALID_WINDOW) && "window" || message.includes(STORAGE_WRONG_ROUTE) && "route" || "unconfigured");
                         break;
                     }
-                    // fallbacks means availability above everything: ANY failing source - down, misconfigured, rejecting, mid-switchover - is skipped and the next covering source takes the call. Only every source failing throws (below). Without fallbacks, a CONNECTED source's error is a real answer and throws.
-                    if (config.fallbacks) {
-                        console.error(`Source failed for ${this.getDebugName()}, falling back to the next source: ${message}`);
-                        if (!source.isConnected()) source.noteFailure();
-                        errors.push(message);
-                        continue;
-                    }
-                    if (source.isConnected()) throw e;
-                    source.noteFailure();
+                    // fallbacks means availability above everything: ANY failing source - down, misconfigured, rejecting, mid-switchover - is skipped and the next covering source takes the call. Only every source failing throws (below).
+                    console.error(`Source failed for ${this.getDebugName()}, falling back to the next source: ${message}`);
+                    if (!source.isConnected()) source.noteFailure();
                     errors.push(message);
+                    continue;
                 }
             }
             if (wrongTarget) {
@@ -198,7 +193,7 @@ export class ArchivesChain implements IArchives {
         }
     }
 
-    // Writes and noFallbacks reads are the same case: take the authoritative node - strictly the first source matching the route and valid window, whether it is up or down - and use it, never falling back to another node. It's important that writing always accesses the same node everywhere, even if that node is down - otherwise we're just writing into the void, and who knows if the writes will even be accepted, or clobbered, or what; and noFallbacks reads want the same node precisely because it is the one writes target. A slow call is almost always better than throwing, so a failing primary is retried (the SAME node, re-resolved each attempt since a config refresh can change which source is primary) until the deadline, then throws.
+    // Writes and fallbacks:false reads are the same case: take the authoritative node - strictly the first source matching the route and valid window, whether it is up or down - and use it, never falling back to another node. It's important that writing always accesses the same node everywhere, even if that node is down - otherwise we're just writing into the void, and who knows if the writes will even be accepted, or clobbered, or what; and fallbacks:false reads want the same node precisely because it is the one writes target. A slow call is almost always better than throwing, so a failing primary is retried (the SAME node, re-resolved each attempt since a config refresh can change which source is primary) until the deadline, then throws.
     private async runPrimary<T>(config: { write?: boolean; route?: number; timeout?: SmartTimeout }, run: (archives: IArchives, sourceUrl: string) => Promise<T>): Promise<T> {
         let retriedWrongWindow = false;
         let retriedWrongRoute = false;
@@ -314,7 +309,7 @@ export class ArchivesChain implements IArchives {
         await this.state.refreshActiveConfig();
     }
 
-    private async request<T>(config: { apiOnly?: boolean; write?: boolean; route?: number; noFallbacks?: boolean; fallbacks?: boolean; retries?: number; fast?: boolean; timeout?: SmartTimeout }, run: (archives: IArchives, sourceUrl: string) => Promise<T>): Promise<T> {
+    private async request<T>(config: { fallbacks: boolean; apiOnly?: boolean; write?: boolean; route?: number; retries?: number; fast?: boolean; timeout?: SmartTimeout }, run: (archives: IArchives, sourceUrl: string) => Promise<T>): Promise<T> {
         let state = await this.state.getState();
         return await this.run(state, config, run);
     }
@@ -359,7 +354,7 @@ export class ArchivesChain implements IArchives {
             // A specific source leaves nothing for the latency ordering to decide
             return await this.get2(fileName, config);
         }
-        return await this.request({ route: getRoute(fileName), noFallbacks: config?.noFallbacks, retries: config?.retries, fast: true, timeout: { path: fileName } }, async (archives, url) => {
+        return await this.request({ fallbacks: !config?.noFallbacks, route: getRoute(fileName), retries: config?.retries, fast: true, timeout: { path: fileName } }, async (archives, url) => {
             let result = await archives.get2(fileName, config);
             // Empty data is a tombstone, not content - see get2
             if (!result || !result.data || !result.data.length && !config?.includeTombstones && !(config?.range && result.size)) return { url };
@@ -376,7 +371,7 @@ export class ArchivesChain implements IArchives {
                 return { data: result.data, writeTime: result.writeTime, size: result.size, url: sourceUrl };
             });
         }
-        return await this.request({ route: getRoute(fileName), noFallbacks: config?.noFallbacks, retries: config?.retries, timeout: { path: fileName } }, async (archives, url) => {
+        return await this.request({ fallbacks: !config?.noFallbacks, route: getRoute(fileName), retries: config?.retries, timeout: { path: fileName } }, async (archives, url) => {
             let result = await archives.get2(fileName, config);
             // Empty data is a tombstone, not content (unless the caller asked for tombstones) - a ranged read of a REAL file can legitimately be empty though (range past EOF), which the total size distinguishes
             if (!result || !result.data || !result.data.length && !config?.includeTombstones && !(config?.range && result.size)) return { url };
@@ -391,15 +386,15 @@ export class ArchivesChain implements IArchives {
                 return result && { ...result, url: sourceUrl } || undefined;
             });
         }
-        return await this.request({ route: getRoute(fileName), noFallbacks: config?.noFallbacks, retries: config?.retries }, async (archives, url) => {
+        return await this.request({ fallbacks: !config?.noFallbacks, route: getRoute(fileName), retries: config?.retries }, async (archives, url) => {
             let result = await archives.getInfo(fileName, config);
             return result && { ...result, url } || undefined;
         });
     }
 
     // Without fallbacks: the AUTHORITATIVE covering ONLY - the first source per route in config order (the same node every write and read targets), down or not. It is NEVER excluded and NEVER substituted, so a listing that can't reach its write nodes retries those same nodes until the deadline and then fails, rather than quietly reading second-hand data off a replica or backblaze. exclude/cooldown/substitution apply ONLY when the caller opted into fallbacks.
-    private selectCoveringSources(state: ChainState, config?: { fallbacks?: boolean; exclude?: Set<SourceWrapper> }): SourceWrapper[] {
-        if (config?.fallbacks) {
+    private selectCoveringSources(state: ChainState, config: { fallbacks: boolean; exclude?: Set<SourceWrapper> }): SourceWrapper[] {
+        if (config.fallbacks) {
             let candidates = state.sources.filter(x => configWindowCurrent(x.config) && x.api && !config.exclude?.has(x));
             let usable = candidates.filter(x => !x.isOnCooldown());
             let chosen = coverRoutes(usable) || coverRoutes(candidates);
@@ -414,63 +409,74 @@ export class ArchivesChain implements IArchives {
         return chosen;
     }
 
-    private async runOnCovering<T>(operation: string, run: (archives: IArchives) => Promise<T>, config?: { fallbacks?: boolean }): Promise<T[]> {
+    private async runOnCovering<T>(operation: string, run: (archives: IArchives) => Promise<T>, config: { fallbacks: boolean }): Promise<T[]> {
         let startTime = Date.now();
         let deadline = Date.now() + COVERING_RETRY_TIMEOUT;
         // Sources that failed during this call - with fallbacks, the next attempt covers their routes with the next source holding them instead
         let failed = new Set<SourceWrapper>();
+        // Why each of them failed, kept for the whole call: when the fallbacks run out, the error names every source that was tried and what each one said, not just whichever covering set happened to be last
+        let allFailures = new Map<SourceWrapper, Error>();
         let tries = 0;
         while (true) {
             tries++;
             let state = await this.state.getState();
-            // Errors name the OPERATION and the SPECIFIC sources that failed - "the find failed because source X is unavailable", never an anonymous failure attributed to the whole chain
-            let outcome = await (async (): Promise<{ values: T[] } | { error: Error }> => {
-                let covering: SourceWrapper[];
-                try {
-                    covering = this.selectCoveringSources(state, { fallbacks: config?.fallbacks, exclude: failed });
-                } catch (e) {
-                    return { error: new Error(`${operation} cannot run: ${(e as Error).message}`) };
+            let selected: SourceWrapper[] | undefined;
+            let coverGap: Error | undefined;
+            try {
+                selected = this.selectCoveringSources(state, { fallbacks: config.fallbacks, exclude: failed });
+            } catch (e) {
+                coverGap = e as Error;
+            }
+            if (!selected) {
+                let described = [...allFailures].map(([source, sourceError]) => `${source.getDebugName()}: ${sourceError.message ?? sourceError}`).join(" | ");
+                let error = new Error(
+                    `${operation} cannot run: ${coverGap!.message}`
+                    + (described ? ` ${allFailures.size} source(s) failed first: ${described}.` : "")
+                    + ` Fallbacks = ${config.fallbacks}. Tries = ${tries}, Took ${formatTime(Date.now() - startTime)}`
+                );
+                // With fallbacks the loop only lands here after every substitute was tried, so waiting will not produce a new source - the caller gets the whole cascade now
+                if (config.fallbacks && allFailures.size) {
+                    throw error;
                 }
-                let values: T[] = [];
-                let failures: { source: SourceWrapper; error: Error }[] = [];
-                let time = Date.now();
-                await Promise.all(covering.map(async (source, index) => {
-                    let api = source.api;
-                    if (!api) {
-                        failed.add(source);
-                        failures.push({ source, error: new Error(`URL-only access, which cannot serve ${operation}`) });
-                        return;
-                    }
-                    try {
-                        values.push(await run(api));
-                    } catch (e) {
-                        if (!source.isConnected()) source.noteFailure();
-                        failed.add(source);
-                        failures.push({ source, error: e as Error });
-                        console.log(`Failed after ${formatTime(Date.now() - time)} index ${index} of ${covering.length}`);
-                    }
-                }));
-                if (!failures.length) return { values };
-                if (failures.length === 1) {
-                    return { error: new Error(`${operation} failed because source ${failures[0].source.getDebugName()} is unavailable: ${failures[0].error.message ?? failures[0].error}. Fallbacks = ${!!config?.fallbacks}. Tries = ${tries}, Took ${formatTime(Date.now() - startTime)}`) };
+                if (Date.now() >= deadline) {
+                    throw error;
+                }
+                console.error(`${error.message}. Retrying in ${COVERING_RETRY_DELAY / 1000}s (giving up at ${formatDateTimeDetailed(deadline)}).`);
+                void this.state.recheckAvailability();
+                await delay(COVERING_RETRY_DELAY);
+                continue;
+            }
+            let covering = selected;
+            // Errors name the OPERATION and the SPECIFIC sources that failed - "the find failed because source X is unavailable", never an anonymous failure attributed to the whole chain
+            let values: T[] = [];
+            let failures: { source: SourceWrapper; error: Error }[] = [];
+            let time = Date.now();
+            await Promise.all(covering.map(async (source, index) => {
+                let api = source.api;
+                if (!api) {
+                    failures.push({ source, error: new Error(`URL-only access, which cannot serve ${operation}`) });
+                    return;
                 }
-                return { error: new Error(`${operation} failed because ${failures.length} of the ${covering.length} covering sources are unavailable: ${failures.map(x => `${x.source.getDebugName()}: ${x.error.message ?? x.error}`).join(" | ")}. Fallbacks = ${!!config?.fallbacks}. Tries = ${tries}, Took ${formatTime(Date.now() - startTime)}`) };
-            })();
-            if ("values" in outcome) return outcome.values;
-            let error = outcome.error;
-            // Substitution comes BEFORE the deadline check: a single connect timeout can eat the entire deadline, and giving up then - without ever trying the substitute that fallbacks exist for - throws exactly when falling back matters most. Substitution cannot loop past the deadline forever: every pass adds its failures to `failed`, so the substitutes run out with the sources.
-            if (config?.fallbacks && failed.size) {
-                let substitutable = false;
                 try {
-                    this.selectCoveringSources(state, { fallbacks: true, exclude: failed });
-                    substitutable = true;
-                } catch { }
-                if (substitutable) {
-                    console.warn(`(retrying with fallbacks) ${error.message}`);
-                    continue;
+                    values.push(await run(api));
+                } catch (e) {
+                    if (!source.isConnected()) source.noteFailure();
+                    failures.push({ source, error: e as Error });
+                    console.log(`Failed after ${formatTime(Date.now() - time)} index ${index} of ${covering.length}`);
                 }
-                // No substitute covers the failed routes - retry the failed sources themselves after the delay
-                failed.clear();
+            }));
+            if (!failures.length) return values;
+            for (let failure of failures) {
+                failed.add(failure.source);
+                allFailures.set(failure.source, failure.error);
+            }
+            let error = failures.length === 1
+                ? new Error(`${operation} failed because source ${failures[0].source.getDebugName()} is unavailable: ${failures[0].error.message ?? failures[0].error}. Fallbacks = ${config.fallbacks}. Tries = ${tries}, Took ${formatTime(Date.now() - startTime)}`)
+                : new Error(`${operation} failed because ${failures.length} of the ${covering.length} sources covering this attempt are unavailable: ${failures.map(x => `${x.source.getDebugName()}: ${x.error.message ?? x.error}`).join(" | ")}. Fallbacks = ${config.fallbacks}. Tries = ${tries}, Took ${formatTime(Date.now() - startTime)}`);
+            // Substitution comes BEFORE the deadline check: a single connect timeout can eat the entire deadline, and giving up then - without ever trying the substitute that fallbacks exist for - throws exactly when falling back matters most. The loop keeps substituting for as long as a covering set exists; every pass adds its failures to `failed`, so it always terminates at the no-covering branch above, which throws everything collected here.
+            if (config.fallbacks) {
+                console.warn(`(retrying with fallbacks) ${error.message}`);
+                continue;
             }
             if (Date.now() >= deadline) {
                 throw error;
@@ -485,7 +491,7 @@ export class ArchivesChain implements IArchives {
         return (await this.findInfo(prefix, config)).map(x => x.path);
     }
     public async findInfo(prefix: string, config?: FindConfig): Promise<ArchiveFileInfo[]> {
-        let results = await this.runOnCovering(`The find of ${JSON.stringify(prefix)}`, archives => archives.findInfo(prefix, config), { fallbacks: config?.fallbacks });
+        let results = await this.runOnCovering(`The find of ${JSON.stringify(prefix)}`, archives => archives.findInfo(prefix, config), { fallbacks: !!config?.fallbacks });
         let byPath = new Map<string, ArchiveFileInfo>();
         for (let list of results) {
             for (let file of list) {
@@ -500,7 +506,7 @@ export class ArchivesChain implements IArchives {
         return merged;
     }
     public async getChangesAfter2(config: ChangesAfterConfig): Promise<ArchiveFileInfo[]> {
-        let results = await this.runOnCovering(`The changes listing since ${formatDateTimeDetailed(config.time)}`, archives => archives.getChangesAfter2(config));
+        let results = await this.runOnCovering(`The changes listing since ${formatDateTimeDetailed(config.time)}`, archives => archives.getChangesAfter2(config), { fallbacks: false });
         let byPath = new Map<string, ArchiveFileInfo>();
         for (let list of results) {
             for (let file of list) {
@@ -520,7 +526,7 @@ export class ArchivesChain implements IArchives {
                 throw new Error(`getSyncStatus is not supported: ${archives.getDebugName()} does not implement it`);
             }
             return await archives.getSyncStatus();
-        });
+        }, { fallbacks: false });
         return {
             allScansComplete: statuses.every(x => x.allScansComplete),
             indexSize: statuses.reduce((sum, x) => sum + x.indexSize, 0),
@@ -530,7 +536,7 @@ export class ArchivesChain implements IArchives {
     public async getConfig(): Promise<ArchivesConfig> {
         let state = await this.state.getState();
         if (!state.sources.some(x => x.api)) return { remoteConfig: state.config };
-        let config = await this.run(state, { apiOnly: true }, archives => archives.getConfig());
+        let config = await this.run(state, { fallbacks: true, apiOnly: true }, archives => archives.getConfig());
         return { ...config, remoteConfig: state.config };
     }
     public async hasWriteAccess(): Promise<boolean> {
@@ -557,7 +563,7 @@ export class ArchivesChain implements IArchives {
             await this.setLargeFile({ path: fileName, ...config, ...bufferChunkStream(data) });
             return fileName;
         }
-        await this.request({ write: true, fallbacks: config?.fallbacks, retries: config?.retries, route: getRoute(fileName), timeout: { uploadBytes: data.length, label: `Upload of ${JSON.stringify(fileName)} (${data.length} bytes)` } }, archives => archives.set(fileName, data, config));
+        await this.request({ fallbacks: !!config?.fallbacks, write: true, retries: config?.retries, route: getRoute(fileName), timeout: { uploadBytes: data.length, label: `Upload of ${JSON.stringify(fileName)} (${data.length} bytes)` } }, archives => archives.set(fileName, data, config));
         return fileName;
     }
 
@@ -599,14 +605,14 @@ export class ArchivesChain implements IArchives {
         return ROUTING_FILE;
     }
     public async del(fileName: string, config?: DelConfig): Promise<void> {
-        await this.request({ write: true, fallbacks: config?.fallbacks, retries: config?.retries, route: getRoute(fileName), timeout: { uploadBytes: 0, label: `Deletion of ${JSON.stringify(fileName)}` } }, archives => archives.del(fileName, config));
+        await this.request({ fallbacks: !!config?.fallbacks, write: true, retries: config?.retries, route: getRoute(fileName), timeout: { uploadBytes: 0, label: `Deletion of ${JSON.stringify(fileName)}` } }, archives => archives.del(fileName, config));
     }
 
     /** See IArchives.undelete: restores a file marked for deletion, dispatched to the write node as SetConfig.undelete (the write node propagates the restore to its peers itself). */
     public async undelete(fileName: string): Promise<void> {
         // set refuses empty buffers, and an undelete carries no data - the byte is ignored
         let placeholder = Buffer.from([1]);
-        await this.request({ write: true, route: getRoute(fileName), timeout: { uploadBytes: placeholder.length, label: `Undelete of ${JSON.stringify(fileName)}` } }, archives => archives.set(fileName, placeholder, { undelete: true }));
+        await this.request({ fallbacks: false, write: true, route: getRoute(fileName), timeout: { uploadBytes: placeholder.length, label: `Undelete of ${JSON.stringify(fileName)}` } }, archives => archives.set(fileName, placeholder, { undelete: true }));
     }
 
     /** See IArchives.move. When one node is the write target for BOTH paths, that node moves the file itself - the bytes never come through us - with the same wrong-window/route re-resolution as any write. When the paths route to different shards no single node holds both, so the move degrades to a copy through us plus a delete, CONFIRMED at the destination before the source is touched. No smart timeout on the node-side move: it can be a big file's worth of node-side work, which the upload-sized deadlines would misjudge. */
@@ -620,7 +626,7 @@ export class ArchivesChain implements IArchives {
         let state = await this.state.getState();
         let target = state.sources.find(x => configWindowCurrent(x.config) && routeContains(x.config.route, fromRoute));
         if (target && routeContains(target.config.route, toRoute)) {
-            await this.request({ write: true, route: fromRoute }, async archives => {
+            await this.request({ fallbacks: false, write: true, route: fromRoute }, async archives => {
                 if (!archives.move) {
                     throw new Error(`Move is not supported by this source: ${archives.getDebugName()} (moving ${JSON.stringify(config.fromPath)} to ${JSON.stringify(config.toPath)})`);
                 }
@@ -731,7 +737,7 @@ export class ArchivesChain implements IArchives {
             return;
         }
         let attempt = 0;
-        await this.request({ write: true, fallbacks: config.fallbacks, retries: config.retries, route }, async archives => {
+        await this.request({ fallbacks: !!config.fallbacks, write: true, retries: config.retries, route }, async archives => {
             attempt++;
             // The previous attempt consumed some (or all) of the stream, and this source needs the file from its first byte
             if (attempt > 1) await restartStream();

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

@@ -96,7 +96,6 @@ class ArchivesRemote {
             machineId: state.machineId,
             ip: state.ip,
             reason: state.reason || "",
-            addMachineCommand: state.addMachineCommand || "",
         };
     }
     async hasWriteAccess() {
@@ -109,7 +108,7 @@ class ArchivesRemote {
             return;
         let state = await this.callAuthed(() => this.controller.getAccessState({ account: this.account }));
         this.lastDeniedLog = Date.now();
-        console.log(`No access to storage account ${JSON.stringify(this.account)} on ${this.parsed.address}:${this.parsed.port} (our machine ${state.machineId}, ip ${state.ip}). ${state.reason || ""} Grant it with: ${state.addMachineCommand || ""}`);
+        console.log(`No access to storage account ${JSON.stringify(this.account)} on ${this.parsed.address}:${this.parsed.port}. ${state.reason || ""}`);
     }
     // Runs a call, authenticating (and re-authenticating after reconnects) and waiting for account access as needed. With waitForAccess false, denied calls throw immediately instead - but the access request is still registered (in the background), so the denial is grantable.
     async call(fnc) {
@@ -238,5 +237,5 @@ class ArchivesRemote {
     }
 }
 exports.ArchivesRemote = ArchivesRemote;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ArchivesRemote.js","sourceRoot":"","sources":["ArchivesRemote.ts"],"names":[],"mappings":"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","sourcesContent":["import { SocketFunction } from \"socket-function/SocketFunction\";\nimport { timeInMinute } from \"socket-function/src/misc\";\nimport { delay } from \"socket-function/src/batching\";\nimport { getIdentityCA, getThreadKeyCert, loadIdentityCA, sign } from \"../../misc/https/certs\";\nimport { IArchives, ArchiveFileInfo, ArchivesConfig, ArchivesSyncStatus, ChangesAfterConfig, DelConfig, FindConfig, GetConfig, GetInfoConfig, MoveFileConfig, SourceConfig, SetConfig, SetLargeFileConfig, LARGE_SET_THRESHOLD, bufferChunkStream } from \"../IArchives\";\nimport { parseHostedUrl, getBucketBaseUrl, buildFileUrl } from \"./remoteConfig\";\nimport {\n    RemoteStorageController, STORAGE_AUTH_PURPOSE,\n    STORAGE_NOT_AUTHENTICATED, STORAGE_ACCESS_DENIED,\n} from \"./storageController\";\n\n// A bucket on our remote storage server (storageServer.ts), used like ArchivesBackblaze. Works in Node.js and the browser. Authenticates with this machine's certs.ts identity; if the account hasn't trusted this machine yet it requests access, and by default waits, logging instructions every minute (calls block until access is granted).\n\nconst ACCESS_RETRY_DELAY = 1000 * 30;\nconst LARGE_FILE_PART_SIZE = 8 * 1024 * 1024;\n// One failed part must not fail a whole large upload: parts are written at explicit offsets (see uploadPart), so a re-sent part is idempotent and can simply be tried again\nconst LARGE_FILE_PART_RETRIES = 3;\nconst LARGE_FILE_PART_RETRY_DELAY = 1000 * 5;\n\nexport type ArchivesRemoteConfig = {\n    // The bucket's routing URL, which addresses the server, account, and bucket in one:\n    //  https://storage.example.com:4444/file/<account>/<bucketName>/storage/storagerouting.json\n    url: string;\n    // false: access-denied calls throw immediately (the error includes the access page link) instead of requesting access and blocking until it is granted (the default).\n    waitForAccess?: boolean;\n    /** The exact routing-config entry this connection represents, sent with every call so the server picks the matching per-route store (one server hosts one store per route). Instances built from a bare URL fabricate one - it will never match, which only works for calls that don't select a store (internal reads, ROUTING_FILE, getConfig). */\n    sourceConfig: SourceConfig;\n};\n\nexport function parseStorageUrl(url: string): { address: string; port: number } {\n    let u = new URL(url);\n    if (u.protocol !== \"https:\") {\n        throw new Error(`Storage URL must use https, got ${JSON.stringify(u.protocol)} in ${JSON.stringify(url)}`);\n    }\n    return { address: u.hostname, port: +u.port || 443 };\n}\n\n// Authenticates a connection to a storage server with this machine's certs.ts identity\nexport async function authenticateStorage(config: { address: string; port: number; nodeId: string }): Promise<{ machineId: string; ip: string }> {\n    // hostServer nodeIds are machine-specific, so connections by domain must target \"any server at this address\" (which is how browsers always connect)\n    SocketFunction.ENABLE_CLIENT_MODE = true;\n    let rootDomain = config.address.split(\".\").slice(-2).join(\".\");\n    await loadIdentityCA(rootDomain);\n    let threadKeyCert = getThreadKeyCert(rootDomain);\n    let issuer = getIdentityCA(rootDomain);\n    let data = {\n        purpose: STORAGE_AUTH_PURPOSE,\n        time: Date.now(),\n        server: `${config.address}:${config.port}`,\n    };\n    let signature = sign(threadKeyCert, data);\n    return await RemoteStorageController.nodes[config.nodeId].authenticate({\n        certPem: threadKeyCert.cert.toString(),\n        issuerPem: issuer.cert.toString(),\n        signature,\n        data,\n    });\n}\n\nexport class ArchivesRemote implements IArchives {\n    constructor(private config: ArchivesRemoteConfig) {\n        // hostServer nodeIds are machine-specific, so connections by domain must target \"any server at this address\" (which is how browsers always connect)\n        SocketFunction.ENABLE_CLIENT_MODE = true;\n    }\n\n    private parsed = parseHostedUrl(this.config.url);\n    private account = this.parsed.account;\n    private bucketName = this.parsed.bucketName;\n    private nodeId = SocketFunction.connect({ address: this.parsed.address, port: this.parsed.port });\n    private controller = RemoteStorageController.nodes[this.nodeId];\n    private lastDeniedLog = 0;\n\n    public getDebugName() {\n        return `remoteStorage ${this.parsed.address}:${this.parsed.port} account ${this.account} bucket ${this.bucketName}`;\n    }\n\n    /** The config travels with every request (the server matches it against its own entries to pick the store), so a config change has to land here - otherwise we keep asking for a source description the server no longer recognizes. Only ever called with a config for the SAME endpoint (see sourceIdentity), so the connection, account, and bucket cannot change under us. */\n    public updateSourceConfig(sourceConfig: SourceConfig): void {\n        if (sourceConfig.url !== this.config.url) {\n            throw new Error(`updateSourceConfig changed endpoints. It must stay on the same endpoint, got ${JSON.stringify(sourceConfig.url)} for ${this.getDebugName()} (${JSON.stringify(this.config.url)})`);\n        }\n        this.config.sourceConfig = sourceConfig;\n    }\n\n    public isConnected(): boolean {\n        return SocketFunction.isNodeConnected(this.nodeId);\n    }\n\n    public async ping(): Promise<{}> {\n        return await this.controller.ping();\n    }\n\n    private async authenticate(): Promise<void> {\n        await authenticateStorage({ address: this.parsed.address, port: this.parsed.port, nodeId: this.nodeId });\n    }\n\n    // Runs a call, authenticating (and re-authenticating after reconnects) as needed. Unlike call(), does NOT wait for account access.\n    private async callAuthed<T>(fnc: () => Promise<T>): Promise<T> {\n        try {\n            return await fnc();\n        } catch (e: any) {\n            if (!String(e.stack || e).includes(STORAGE_NOT_AUTHENTICATED)) throw e;\n            await this.authenticate();\n            return await fnc();\n        }\n    }\n\n    // Returns undefined if this machine has access to the account. Otherwise returns our machineId + ip as the server sees them, why we were refused, and the exact command that grants access.\n    public async waitingForAccess(): Promise<{ machineId: string; ip: string; reason: string; addMachineCommand: string } | undefined> {\n        let state = await this.callAuthed(() => this.controller.getAccessState({ account: this.account }));\n        if (state.hasAccess) return undefined;\n        return {\n            machineId: state.machineId,\n            ip: state.ip,\n            reason: state.reason || \"\",\n            addMachineCommand: state.addMachineCommand || \"\",\n        };\n    }\n\n    public async hasWriteAccess(): Promise<boolean> {\n        let state = await this.callAuthed(() => this.controller.getAccessState({ account: this.account }));\n        return !!state.hasAccess;\n    }\n\n    // Logs how to get access, at most once a minute. There is nothing to register any more: the server decides from the signed repo, so what it hands back is the command that puts us in it.\n    private async registerAccessRequest(): Promise<void> {\n        if (Date.now() - this.lastDeniedLog < timeInMinute) return;\n        let state = await this.callAuthed(() => this.controller.getAccessState({ account: this.account }));\n        this.lastDeniedLog = Date.now();\n        console.log(`No access to storage account ${JSON.stringify(this.account)} on ${this.parsed.address}:${this.parsed.port} (our machine ${state.machineId}, ip ${state.ip}). ${state.reason || \"\"} Grant it with: ${state.addMachineCommand || \"\"}`);\n    }\n\n    // Runs a call, authenticating (and re-authenticating after reconnects) and waiting for account access as needed. With waitForAccess false, denied calls throw immediately instead - but the access request is still registered (in the background), so the denial is grantable.\n    private async call<T>(fnc: () => Promise<T>): Promise<T> {\n        while (true) {\n            try {\n                return await fnc();\n            } catch (e: any) {\n                let message = String(e.stack || e);\n                if (message.includes(STORAGE_NOT_AUTHENTICATED)) {\n                    await this.authenticate();\n                    continue;\n                }\n                if (message.includes(STORAGE_ACCESS_DENIED)) {\n                    if (this.config.waitForAccess === false) {\n                        void this.registerAccessRequest().catch(() => { });\n                        throw e;\n                    }\n                    await this.registerAccessRequest();\n                    await delay(ACCESS_RETRY_DELAY);\n                    continue;\n                }\n                throw e;\n            }\n        }\n    }\n\n    public async get(fileName: string, config?: GetConfig): 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?: GetConfig): Promise<{ data: Buffer; writeTime: number; size: number } | undefined> {\n        let result = await this.call(() => this.controller.get2({ account: this.account, bucketName: this.bucketName, path: fileName, sourceConfig: this.config.sourceConfig, range: config?.range, internal: config?.internal, includeTombstones: config?.includeTombstones, includeMarked: config?.includeMarked }));\n        return result && { data: Buffer.from(result.data), writeTime: result.writeTime, size: result.size } || undefined;\n    }\n    public async set(fileName: string, data: Buffer, config?: SetConfig): Promise<string> {\n        if (!data.length) {\n            throw new Error(`Empty write refused: set was called with an empty buffer for ${JSON.stringify(fileName)} on ${this.getDebugName()}: an empty file IS a deletion in this system and would read back as missing - call del instead`);\n        }\n        if (data.length > LARGE_SET_THRESHOLD) {\n            // One giant message would exceed the wire limit and lag every other client sharing this connection - stream it instead. The config travels with it, so crossing the threshold changes only HOW the bytes move, never what the write means.\n            await this.setLargeFile({ path: fileName, ...config, ...bufferChunkStream(data) });\n            return fileName;\n        }\n        await this.call(() => this.controller.set({ account: this.account, bucketName: this.bucketName, path: fileName, data, sourceConfig: this.config.sourceConfig, lastModified: config?.lastModified, forceSetImmutable: config?.forceSetImmutable, internal: config?.internal, undelete: config?.undelete }));\n        return fileName;\n    }\n    public async del(fileName: string, config?: DelConfig): Promise<void> {\n        await this.call(() => this.controller.del({ account: this.account, bucketName: this.bucketName, path: fileName, sourceConfig: this.config.sourceConfig, lastModified: config?.lastModified, internal: config?.internal }));\n    }\n    public async move(config: MoveFileConfig): Promise<void> {\n        await this.call(() => this.controller.move({ account: this.account, bucketName: this.bucketName, fromPath: config.fromPath, toPath: config.toPath, sourceConfig: this.config.sourceConfig }));\n    }\n    public async getInfo(fileName: string, config?: GetInfoConfig): Promise<{ writeTime: number; size: number } | undefined> {\n        return await this.call(() => this.controller.getInfo({ account: this.account, bucketName: this.bucketName, path: fileName, sourceConfig: this.config.sourceConfig, includeTombstones: config?.includeTombstones }));\n    }\n    public async findInfo(prefix: string, config?: FindConfig): Promise<ArchiveFileInfo[]> {\n        return await this.call(() => this.controller.findInfo({ account: this.account, bucketName: this.bucketName, prefix, sourceConfig: this.config.sourceConfig, shallow: config?.shallow, type: config?.type, includeMarked: config?.includeMarked, internal: config?.internal }));\n    }\n    public async find(prefix: string, config?: FindConfig): Promise<string[]> {\n        return (await this.findInfo(prefix, config)).map(x => x.path);\n    }\n    public async getChangesAfter2(config: ChangesAfterConfig): Promise<ArchiveFileInfo[]> {\n        return await this.call(() => this.controller.getChangesAfter2({ account: this.account, bucketName: this.bucketName, sourceConfig: this.config.sourceConfig, time: config.time, routes: config.routes, internal: config.internal }));\n    }\n    public async getConfig(): Promise<ArchivesConfig> {\n        return await this.call(() => this.controller.getArchivesConfig({ account: this.account, bucketName: this.bucketName }));\n    }\n    public async getSyncStatus(): Promise<ArchivesSyncStatus> {\n        return await this.call(() => this.controller.getSyncStatus({ account: this.account, bucketName: this.bucketName }));\n    }\n\n    public async setLargeFile(config: SetLargeFileConfig): Promise<void> {\n        // Ensure we're authenticated with access BEFORE consuming any data (the stream cannot be rewound, so we can't use the retry loop around the actual upload)\n        await this.call(() => this.controller.getInfo({ account: this.account, bucketName: this.bucketName, path: config.path, sourceConfig: this.config.sourceConfig }));\n        // The write's semantics (immutability, ordering, internal) are decided by the server at start, before any bytes move - a rejection then costs nothing, while one at finish would waste the whole transfer\n        let uploadId = await this.controller.startLargeFile({\n            account: this.account,\n            bucketName: this.bucketName,\n            path: config.path,\n            sourceConfig: this.config.sourceConfig,\n            lastModified: config.lastModified,\n            forceSetImmutable: config.forceSetImmutable,\n            noChecks: config.noChecks,\n            internal: config.internal,\n        });\n        try {\n            // The upload's absolute position: every part carries its offset, so the server writes it positionally and a retried part lands on the same bytes instead of appending twice\n            let uploadOffset = 0;\n            while (true) {\n                let data = await config.getNextData();\n                if (!data) break;\n                for (let chunkStart = 0; chunkStart < data.length; chunkStart += LARGE_FILE_PART_SIZE) {\n                    let part = data.subarray(chunkStart, chunkStart + LARGE_FILE_PART_SIZE);\n                    let partOffset = uploadOffset;\n                    uploadOffset += part.length;\n                    let attempt = 0;\n                    while (true) {\n                        try {\n                            await this.controller.uploadPart({ uploadId, data: part, offset: partOffset });\n                            break;\n                        } catch (e) {\n                            attempt++;\n                            if (attempt > LARGE_FILE_PART_RETRIES) throw e;\n                            console.warn(`Part at offset ${partOffset} (${part.length} bytes) of ${JSON.stringify(config.path)} to ${this.getDebugName()} failed (attempt ${attempt} of ${LARGE_FILE_PART_RETRIES + 1}), retrying in ${LARGE_FILE_PART_RETRY_DELAY / 1000}s: ${(e as Error).stack ?? e}`);\n                            await delay(LARGE_FILE_PART_RETRY_DELAY);\n                        }\n                    }\n                }\n            }\n            await this.controller.finishLargeFile({ uploadId });\n        } catch (e) {\n            try {\n                await this.controller.cancelLargeFile({ uploadId });\n            } catch { }\n            throw e;\n        }\n    }\n\n    public async getURL(path: string): Promise<string> {\n        // Only actually loads for public buckets (the server rejects plain URL reads otherwise)\n        return buildFileUrl(getBucketBaseUrl(this.config.url), path);\n    }\n}\n"]}
- /* _JS_SOURCE_HASH = "fa6a039860b926d976cd922ce78372b7e6220754ba3771a93b6fb1722b320e5e"; */
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ArchivesRemote.js","sourceRoot":"","sources":["ArchivesRemote.ts"],"names":[],"mappings":"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","sourcesContent":["import { SocketFunction } from \"socket-function/SocketFunction\";\nimport { timeInMinute } from \"socket-function/src/misc\";\nimport { delay } from \"socket-function/src/batching\";\nimport { getIdentityCA, getThreadKeyCert, loadIdentityCA, sign } from \"../../misc/https/certs\";\nimport { IArchives, ArchiveFileInfo, ArchivesConfig, ArchivesSyncStatus, ChangesAfterConfig, DelConfig, FindConfig, GetConfig, GetInfoConfig, MoveFileConfig, SourceConfig, SetConfig, SetLargeFileConfig, LARGE_SET_THRESHOLD, bufferChunkStream } from \"../IArchives\";\nimport { parseHostedUrl, getBucketBaseUrl, buildFileUrl } from \"./remoteConfig\";\nimport {\n    RemoteStorageController, STORAGE_AUTH_PURPOSE,\n    STORAGE_NOT_AUTHENTICATED, STORAGE_ACCESS_DENIED,\n} from \"./storageController\";\n\n// A bucket on our remote storage server (storageServer.ts), used like ArchivesBackblaze. Works in Node.js and the browser. Authenticates with this machine's certs.ts identity; if the account hasn't trusted this machine yet it requests access, and by default waits, logging instructions every minute (calls block until access is granted).\n\nconst ACCESS_RETRY_DELAY = 1000 * 30;\nconst LARGE_FILE_PART_SIZE = 8 * 1024 * 1024;\n// One failed part must not fail a whole large upload: parts are written at explicit offsets (see uploadPart), so a re-sent part is idempotent and can simply be tried again\nconst LARGE_FILE_PART_RETRIES = 3;\nconst LARGE_FILE_PART_RETRY_DELAY = 1000 * 5;\n\nexport type ArchivesRemoteConfig = {\n    // The bucket's routing URL, which addresses the server, account, and bucket in one:\n    //  https://storage.example.com:4444/file/<account>/<bucketName>/storage/storagerouting.json\n    url: string;\n    // false: access-denied calls throw immediately (the error includes the access page link) instead of requesting access and blocking until it is granted (the default).\n    waitForAccess?: boolean;\n    /** The exact routing-config entry this connection represents, sent with every call so the server picks the matching per-route store (one server hosts one store per route). Instances built from a bare URL fabricate one - it will never match, which only works for calls that don't select a store (internal reads, ROUTING_FILE, getConfig). */\n    sourceConfig: SourceConfig;\n};\n\nexport function parseStorageUrl(url: string): { address: string; port: number } {\n    let u = new URL(url);\n    if (u.protocol !== \"https:\") {\n        throw new Error(`Storage URL must use https, got ${JSON.stringify(u.protocol)} in ${JSON.stringify(url)}`);\n    }\n    return { address: u.hostname, port: +u.port || 443 };\n}\n\n// Authenticates a connection to a storage server with this machine's certs.ts identity\nexport async function authenticateStorage(config: { address: string; port: number; nodeId: string }): Promise<{ machineId: string; ip: string }> {\n    // hostServer nodeIds are machine-specific, so connections by domain must target \"any server at this address\" (which is how browsers always connect)\n    SocketFunction.ENABLE_CLIENT_MODE = true;\n    let rootDomain = config.address.split(\".\").slice(-2).join(\".\");\n    await loadIdentityCA(rootDomain);\n    let threadKeyCert = getThreadKeyCert(rootDomain);\n    let issuer = getIdentityCA(rootDomain);\n    let data = {\n        purpose: STORAGE_AUTH_PURPOSE,\n        time: Date.now(),\n        server: `${config.address}:${config.port}`,\n    };\n    let signature = sign(threadKeyCert, data);\n    return await RemoteStorageController.nodes[config.nodeId].authenticate({\n        certPem: threadKeyCert.cert.toString(),\n        issuerPem: issuer.cert.toString(),\n        signature,\n        data,\n    });\n}\n\nexport class ArchivesRemote implements IArchives {\n    constructor(private config: ArchivesRemoteConfig) {\n        // hostServer nodeIds are machine-specific, so connections by domain must target \"any server at this address\" (which is how browsers always connect)\n        SocketFunction.ENABLE_CLIENT_MODE = true;\n    }\n\n    private parsed = parseHostedUrl(this.config.url);\n    private account = this.parsed.account;\n    private bucketName = this.parsed.bucketName;\n    private nodeId = SocketFunction.connect({ address: this.parsed.address, port: this.parsed.port });\n    private controller = RemoteStorageController.nodes[this.nodeId];\n    private lastDeniedLog = 0;\n\n    public getDebugName() {\n        return `remoteStorage ${this.parsed.address}:${this.parsed.port} account ${this.account} bucket ${this.bucketName}`;\n    }\n\n    /** The config travels with every request (the server matches it against its own entries to pick the store), so a config change has to land here - otherwise we keep asking for a source description the server no longer recognizes. Only ever called with a config for the SAME endpoint (see sourceIdentity), so the connection, account, and bucket cannot change under us. */\n    public updateSourceConfig(sourceConfig: SourceConfig): void {\n        if (sourceConfig.url !== this.config.url) {\n            throw new Error(`updateSourceConfig changed endpoints. It must stay on the same endpoint, got ${JSON.stringify(sourceConfig.url)} for ${this.getDebugName()} (${JSON.stringify(this.config.url)})`);\n        }\n        this.config.sourceConfig = sourceConfig;\n    }\n\n    public isConnected(): boolean {\n        return SocketFunction.isNodeConnected(this.nodeId);\n    }\n\n    public async ping(): Promise<{}> {\n        return await this.controller.ping();\n    }\n\n    private async authenticate(): Promise<void> {\n        await authenticateStorage({ address: this.parsed.address, port: this.parsed.port, nodeId: this.nodeId });\n    }\n\n    // Runs a call, authenticating (and re-authenticating after reconnects) as needed. Unlike call(), does NOT wait for account access.\n    private async callAuthed<T>(fnc: () => Promise<T>): Promise<T> {\n        try {\n            return await fnc();\n        } catch (e: any) {\n            if (!String(e.stack || e).includes(STORAGE_NOT_AUTHENTICATED)) throw e;\n            await this.authenticate();\n            return await fnc();\n        }\n    }\n\n    // Returns undefined if this machine has access to the account. Otherwise returns our machineId + ip as the server sees them, why we were refused, and the exact command that grants access.\n    public async waitingForAccess(): Promise<{ machineId: string; ip: string; reason: string } | undefined> {\n        let state = await this.callAuthed(() => this.controller.getAccessState({ account: this.account }));\n        if (state.hasAccess) return undefined;\n        return {\n            machineId: state.machineId,\n            ip: state.ip,\n            reason: state.reason || \"\",\n        };\n    }\n\n    public async hasWriteAccess(): Promise<boolean> {\n        let state = await this.callAuthed(() => this.controller.getAccessState({ account: this.account }));\n        return !!state.hasAccess;\n    }\n\n    // Logs how to get access, at most once a minute. There is nothing to register any more: the server decides from the signed repo, so what it hands back is the command that puts us in it.\n    private async registerAccessRequest(): Promise<void> {\n        if (Date.now() - this.lastDeniedLog < timeInMinute) return;\n        let state = await this.callAuthed(() => this.controller.getAccessState({ account: this.account }));\n        this.lastDeniedLog = Date.now();\n        console.log(`No access to storage account ${JSON.stringify(this.account)} on ${this.parsed.address}:${this.parsed.port}. ${state.reason || \"\"}`);\n    }\n\n    // Runs a call, authenticating (and re-authenticating after reconnects) and waiting for account access as needed. With waitForAccess false, denied calls throw immediately instead - but the access request is still registered (in the background), so the denial is grantable.\n    private async call<T>(fnc: () => Promise<T>): Promise<T> {\n        while (true) {\n            try {\n                return await fnc();\n            } catch (e: any) {\n                let message = String(e.stack || e);\n                if (message.includes(STORAGE_NOT_AUTHENTICATED)) {\n                    await this.authenticate();\n                    continue;\n                }\n                if (message.includes(STORAGE_ACCESS_DENIED)) {\n                    if (this.config.waitForAccess === false) {\n                        void this.registerAccessRequest().catch(() => { });\n                        throw e;\n                    }\n                    await this.registerAccessRequest();\n                    await delay(ACCESS_RETRY_DELAY);\n                    continue;\n                }\n                throw e;\n            }\n        }\n    }\n\n    public async get(fileName: string, config?: GetConfig): 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?: GetConfig): Promise<{ data: Buffer; writeTime: number; size: number } | undefined> {\n        let result = await this.call(() => this.controller.get2({ account: this.account, bucketName: this.bucketName, path: fileName, sourceConfig: this.config.sourceConfig, range: config?.range, internal: config?.internal, includeTombstones: config?.includeTombstones, includeMarked: config?.includeMarked }));\n        return result && { data: Buffer.from(result.data), writeTime: result.writeTime, size: result.size } || undefined;\n    }\n    public async set(fileName: string, data: Buffer, config?: SetConfig): Promise<string> {\n        if (!data.length) {\n            throw new Error(`Empty write refused: set was called with an empty buffer for ${JSON.stringify(fileName)} on ${this.getDebugName()}: an empty file IS a deletion in this system and would read back as missing - call del instead`);\n        }\n        if (data.length > LARGE_SET_THRESHOLD) {\n            // One giant message would exceed the wire limit and lag every other client sharing this connection - stream it instead. The config travels with it, so crossing the threshold changes only HOW the bytes move, never what the write means.\n            await this.setLargeFile({ path: fileName, ...config, ...bufferChunkStream(data) });\n            return fileName;\n        }\n        await this.call(() => this.controller.set({ account: this.account, bucketName: this.bucketName, path: fileName, data, sourceConfig: this.config.sourceConfig, lastModified: config?.lastModified, forceSetImmutable: config?.forceSetImmutable, internal: config?.internal, undelete: config?.undelete }));\n        return fileName;\n    }\n    public async del(fileName: string, config?: DelConfig): Promise<void> {\n        await this.call(() => this.controller.del({ account: this.account, bucketName: this.bucketName, path: fileName, sourceConfig: this.config.sourceConfig, lastModified: config?.lastModified, internal: config?.internal }));\n    }\n    public async move(config: MoveFileConfig): Promise<void> {\n        await this.call(() => this.controller.move({ account: this.account, bucketName: this.bucketName, fromPath: config.fromPath, toPath: config.toPath, sourceConfig: this.config.sourceConfig }));\n    }\n    public async getInfo(fileName: string, config?: GetInfoConfig): Promise<{ writeTime: number; size: number } | undefined> {\n        return await this.call(() => this.controller.getInfo({ account: this.account, bucketName: this.bucketName, path: fileName, sourceConfig: this.config.sourceConfig, includeTombstones: config?.includeTombstones }));\n    }\n    public async findInfo(prefix: string, config?: FindConfig): Promise<ArchiveFileInfo[]> {\n        return await this.call(() => this.controller.findInfo({ account: this.account, bucketName: this.bucketName, prefix, sourceConfig: this.config.sourceConfig, shallow: config?.shallow, type: config?.type, includeMarked: config?.includeMarked, internal: config?.internal }));\n    }\n    public async find(prefix: string, config?: FindConfig): Promise<string[]> {\n        return (await this.findInfo(prefix, config)).map(x => x.path);\n    }\n    public async getChangesAfter2(config: ChangesAfterConfig): Promise<ArchiveFileInfo[]> {\n        return await this.call(() => this.controller.getChangesAfter2({ account: this.account, bucketName: this.bucketName, sourceConfig: this.config.sourceConfig, time: config.time, routes: config.routes, internal: config.internal }));\n    }\n    public async getConfig(): Promise<ArchivesConfig> {\n        return await this.call(() => this.controller.getArchivesConfig({ account: this.account, bucketName: this.bucketName }));\n    }\n    public async getSyncStatus(): Promise<ArchivesSyncStatus> {\n        return await this.call(() => this.controller.getSyncStatus({ account: this.account, bucketName: this.bucketName }));\n    }\n\n    public async setLargeFile(config: SetLargeFileConfig): Promise<void> {\n        // Ensure we're authenticated with access BEFORE consuming any data (the stream cannot be rewound, so we can't use the retry loop around the actual upload)\n        await this.call(() => this.controller.getInfo({ account: this.account, bucketName: this.bucketName, path: config.path, sourceConfig: this.config.sourceConfig }));\n        // The write's semantics (immutability, ordering, internal) are decided by the server at start, before any bytes move - a rejection then costs nothing, while one at finish would waste the whole transfer\n        let uploadId = await this.controller.startLargeFile({\n            account: this.account,\n            bucketName: this.bucketName,\n            path: config.path,\n            sourceConfig: this.config.sourceConfig,\n            lastModified: config.lastModified,\n            forceSetImmutable: config.forceSetImmutable,\n            noChecks: config.noChecks,\n            internal: config.internal,\n        });\n        try {\n            // The upload's absolute position: every part carries its offset, so the server writes it positionally and a retried part lands on the same bytes instead of appending twice\n            let uploadOffset = 0;\n            while (true) {\n                let data = await config.getNextData();\n                if (!data) break;\n                for (let chunkStart = 0; chunkStart < data.length; chunkStart += LARGE_FILE_PART_SIZE) {\n                    let part = data.subarray(chunkStart, chunkStart + LARGE_FILE_PART_SIZE);\n                    let partOffset = uploadOffset;\n                    uploadOffset += part.length;\n                    let attempt = 0;\n                    while (true) {\n                        try {\n                            await this.controller.uploadPart({ uploadId, data: part, offset: partOffset });\n                            break;\n                        } catch (e) {\n                            attempt++;\n                            if (attempt > LARGE_FILE_PART_RETRIES) throw e;\n                            console.warn(`Part at offset ${partOffset} (${part.length} bytes) of ${JSON.stringify(config.path)} to ${this.getDebugName()} failed (attempt ${attempt} of ${LARGE_FILE_PART_RETRIES + 1}), retrying in ${LARGE_FILE_PART_RETRY_DELAY / 1000}s: ${(e as Error).stack ?? e}`);\n                            await delay(LARGE_FILE_PART_RETRY_DELAY);\n                        }\n                    }\n                }\n            }\n            await this.controller.finishLargeFile({ uploadId });\n        } catch (e) {\n            try {\n                await this.controller.cancelLargeFile({ uploadId });\n            } catch { }\n            throw e;\n        }\n    }\n\n    public async getURL(path: string): Promise<string> {\n        // Only actually loads for public buckets (the server rejects plain URL reads otherwise)\n        return buildFileUrl(getBucketBaseUrl(this.config.url), path);\n    }\n}\n"]}
+ /* _JS_SOURCE_HASH = "0762b5f2ba7bf006bde84fac70547f73f9672822870429aba858b9fed43c07e9"; */