sliftutils 1.7.71 → 1.7.73

package/storage/remoteStorage/ArchivesRemote.d.ts

@@ -1,9 +1,11 @@
 /// <reference types="node" />
 /// <reference types="node" />
-import { IArchives, ArchiveFileInfo, ArchivesConfig, ArchivesSyncStatus, ChangesAfterConfig, DelConfig, GetConfig, GetInfoConfig, SetConfig } from "../IArchives";
+import { IArchives, ArchiveFileInfo, ArchivesConfig, ArchivesSyncStatus, ChangesAfterConfig, DelConfig, FindConfig, GetConfig, GetInfoConfig, SourceConfig, SetConfig } from "../IArchives";
 export type ArchivesRemoteConfig = {
     url: string;
     waitForAccess?: boolean;
+    /** 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). */
+    sourceConfig: SourceConfig;
 };
 export declare function parseStorageUrl(url: string): {
     address: string;
@@ -51,14 +53,8 @@ export declare class ArchivesRemote implements IArchives {
         writeTime: number;
         size: number;
     } | undefined>;
-    findInfo(prefix: string, config?: {
-        shallow?: boolean;
-        type: "files" | "folders";
-    }): Promise<ArchiveFileInfo[]>;
-    find(prefix: string, config?: {
-        shallow?: boolean;
-        type: "files" | "folders";
-    }): Promise<string[]>;
+    findInfo(prefix: string, config?: FindConfig): Promise<ArchiveFileInfo[]>;
+    find(prefix: string, config?: FindConfig): Promise<string[]>;
     getChangesAfter2(config: ChangesAfterConfig): Promise<ArchiveFileInfo[]>;
     getConfig(): Promise<ArchivesConfig>;
     getSyncStatus(): Promise<ArchivesSyncStatus>;

package/storage/remoteStorage/ArchivesRemote.ts

@@ -2,7 +2,7 @@ import { SocketFunction } from "socket-function/SocketFunction";
 import { timeInMinute } from "socket-function/src/misc";
 import { delay } from "socket-function/src/batching";
 import { getIdentityCA, loadIdentityCA, sign } from "../../misc/https/certs";
-import { IArchives, ArchiveFileInfo, ArchivesConfig, ArchivesSyncStatus, ChangesAfterConfig, DelConfig, GetConfig, GetInfoConfig, SetConfig, LARGE_SET_THRESHOLD, bufferChunkStream } from "../IArchives";
+import { IArchives, ArchiveFileInfo, ArchivesConfig, ArchivesSyncStatus, ChangesAfterConfig, DelConfig, FindConfig, GetConfig, GetInfoConfig, SourceConfig, SetConfig, LARGE_SET_THRESHOLD, bufferChunkStream } from "../IArchives";
 import { parseHostedUrl, getBucketBaseUrl, buildFileUrl } from "./remoteConfig";
 import {
     RemoteStorageController, STORAGE_AUTH_PURPOSE,
@@ -20,6 +20,8 @@ export type ArchivesRemoteConfig = {
     url: string;
     // 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).
     waitForAccess?: boolean;
+    /** 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). */
+    sourceConfig: SourceConfig;
 };
 
 export function parseStorageUrl(url: string): { address: string; port: number } {
@@ -88,9 +90,9 @@ export class ArchivesRemote implements IArchives {
 
     // Returns undefined if this machine has access to the account. Otherwise puts in an access request and returns our machineId + ip (so the caller can display them alongside the link, for the approver to match the incoming request) and the link to the grant page.
     public async waitingForAccess(): Promise<{ link: string; machineId: string; ip: string } | undefined> {
-        let state = await this.callAuthed(() => this.controller.getAccessState(this.account));
+        let state = await this.callAuthed(() => this.controller.getAccessState({ account: this.account }));
         if (state.hasAccess) return undefined;
-        let requested = await this.callAuthed(() => this.controller.requestAccess(this.account));
+        let requested = await this.callAuthed(() => this.controller.requestAccess({ account: this.account }));
         return {
             link: `https://${this.parsed.address}:${this.parsed.port}/${this.account}`,
             machineId: requested.machineId,
@@ -99,13 +101,13 @@ export class ArchivesRemote implements IArchives {
     }
 
     public async hasWriteAccess(): Promise<boolean> {
-        let state = await this.callAuthed(() => this.controller.getAccessState(this.account));
+        let state = await this.callAuthed(() => this.controller.getAccessState({ account: this.account }));
         return !!state.hasAccess;
     }
 
     // Registers our access request server-side (so an admin has a requestId to grant) and logs the grant instructions, at most once a minute
     private async registerAccessRequest(): Promise<void> {
-        let requested = await this.callAuthed(() => this.controller.requestAccess(this.account));
+        let requested = await this.callAuthed(() => this.controller.requestAccess({ account: this.account }));
         if (Date.now() - this.lastDeniedLog > timeInMinute) {
             this.lastDeniedLog = Date.now();
             console.log(`No access to storage account ${JSON.stringify(this.account)} on ${this.parsed.address}:${this.parsed.port} (our machine ${requested.machineId}, ip ${requested.ip}). See https://${this.parsed.address}:${this.parsed.port}/${this.account} - or grant it with: ${requested.grantAccessCommand}`);
@@ -142,56 +144,59 @@ export class ArchivesRemote implements IArchives {
         return result && result.data || undefined;
     }
     public async get2(fileName: string, config?: GetConfig): Promise<{ data: Buffer; writeTime: number; size: number } | undefined> {
-        let result = await this.call(() => this.controller.get2(this.account, this.bucketName, fileName, config?.range, config?.internal));
+        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 }));
         return result && { data: Buffer.from(result.data), writeTime: result.writeTime, size: result.size } || undefined;
     }
     public async set(fileName: string, data: Buffer, config?: SetConfig): Promise<string> {
+        if (!data.length) {
+            throw new Error(`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`);
+        }
         if (data.length > LARGE_SET_THRESHOLD) {
             // One giant message would exceed the wire limit and lag every other client sharing this connection - stream it instead. (The large-file path cannot carry forceSetImmutable/noChecks/internal; large pushes accept plain-write semantics, and reconciliation's per-file error handling absorbs the rare immutable rejection.)
             await this.setLargeFile({ path: fileName, lastModified: config?.lastModified, getNextData: bufferChunkStream(data) });
             return fileName;
         }
-        await this.call(() => this.controller.set(this.account, this.bucketName, fileName, data, config?.lastModified, config?.forceSetImmutable, config?.internal));
+        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 }));
         return fileName;
     }
     public async del(fileName: string, config?: DelConfig): Promise<void> {
-        await this.call(() => this.controller.del(this.account, this.bucketName, fileName, config?.lastModified, config?.internal));
+        await this.call(() => this.controller.del({ account: this.account, bucketName: this.bucketName, path: fileName, sourceConfig: this.config.sourceConfig, lastModified: config?.lastModified, internal: config?.internal }));
     }
     public async getInfo(fileName: string, config?: GetInfoConfig): Promise<{ writeTime: number; size: number } | undefined> {
-        return await this.call(() => this.controller.getInfo(this.account, this.bucketName, fileName, config?.includeTombstones));
+        return await this.call(() => this.controller.getInfo({ account: this.account, bucketName: this.bucketName, path: fileName, sourceConfig: this.config.sourceConfig, includeTombstones: config?.includeTombstones }));
     }
-    public async findInfo(prefix: string, config?: { shallow?: boolean; type: "files" | "folders" }): Promise<ArchiveFileInfo[]> {
-        return await this.call(() => this.controller.findInfo(this.account, this.bucketName, prefix, config));
+    public async findInfo(prefix: string, config?: FindConfig): Promise<ArchiveFileInfo[]> {
+        return await this.call(() => this.controller.findInfo({ account: this.account, bucketName: this.bucketName, prefix, sourceConfig: this.config.sourceConfig, shallow: config?.shallow, type: config?.type }));
     }
-    public async find(prefix: string, config?: { shallow?: boolean; type: "files" | "folders" }): Promise<string[]> {
+    public async find(prefix: string, config?: FindConfig): Promise<string[]> {
         return (await this.findInfo(prefix, config)).map(x => x.path);
     }
     public async getChangesAfter2(config: ChangesAfterConfig): Promise<ArchiveFileInfo[]> {
-        return await this.call(() => this.controller.getChangesAfter2(this.account, this.bucketName, config));
+        return await this.call(() => this.controller.getChangesAfter2({ account: this.account, bucketName: this.bucketName, sourceConfig: this.config.sourceConfig, time: config.time, routes: config.routes }));
     }
     public async getConfig(): Promise<ArchivesConfig> {
-        return await this.call(() => this.controller.getArchivesConfig(this.account, this.bucketName));
+        return await this.call(() => this.controller.getArchivesConfig({ account: this.account, bucketName: this.bucketName }));
     }
     public async getSyncStatus(): Promise<ArchivesSyncStatus> {
-        return await this.call(() => this.controller.getSyncStatus(this.account, this.bucketName));
+        return await this.call(() => this.controller.getSyncStatus({ account: this.account, bucketName: this.bucketName }));
     }
 
     public async setLargeFile(config: { path: string; lastModified?: number; getNextData(): Promise<Buffer | undefined> }): Promise<void> {
         // 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)
-        await this.call(() => this.controller.getInfo(this.account, this.bucketName, config.path));
-        let uploadId = await this.controller.startLargeFile(this.account, this.bucketName, config.path, config.lastModified);
+        await this.call(() => this.controller.getInfo({ account: this.account, bucketName: this.bucketName, path: config.path, sourceConfig: this.config.sourceConfig }));
+        let uploadId = await this.controller.startLargeFile({ account: this.account, bucketName: this.bucketName, path: config.path, sourceConfig: this.config.sourceConfig, lastModified: config.lastModified });
         try {
             while (true) {
                 let data = await config.getNextData();
                 if (!data) break;
                 for (let offset = 0; offset < data.length; offset += LARGE_FILE_PART_SIZE) {
-                    await this.controller.uploadPart(uploadId, data.subarray(offset, offset + LARGE_FILE_PART_SIZE));
+                    await this.controller.uploadPart({ uploadId, data: data.subarray(offset, offset + LARGE_FILE_PART_SIZE) });
                 }
             }
-            await this.controller.finishLargeFile(uploadId);
+            await this.controller.finishLargeFile({ uploadId });
         } catch (e) {
             try {
-                await this.controller.cancelLargeFile(uploadId);
+                await this.controller.cancelLargeFile({ uploadId });
             } catch { }
             throw e;
         }

package/storage/remoteStorage/ArchivesUrl.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 /// <reference types="node" />
-import { IArchives, ArchiveFileInfo, ArchivesConfig, ChangesAfterConfig, GetConfig, GetInfoConfig } from "../IArchives";
+import { IArchives, ArchiveFileInfo, ArchivesConfig, ChangesAfterConfig, FindConfig, GetConfig, GetInfoConfig } from "../IArchives";
 export declare class ArchivesUrl implements IArchives {
     private base;
     constructor(base: string);
@@ -24,14 +24,8 @@ export declare class ArchivesUrl implements IArchives {
         path: string;
         getNextData(): Promise<Buffer | undefined>;
     }): Promise<void>;
-    find(prefix: string, config?: {
-        shallow?: boolean;
-        type: "files" | "folders";
-    }): Promise<string[]>;
-    findInfo(prefix: string, config?: {
-        shallow?: boolean;
-        type: "files" | "folders";
-    }): Promise<ArchiveFileInfo[]>;
+    find(prefix: string, config?: FindConfig): Promise<string[]>;
+    findInfo(prefix: string, config?: FindConfig): Promise<ArchiveFileInfo[]>;
     getChangesAfter2(config: ChangesAfterConfig): Promise<ArchiveFileInfo[]>;
     getURL(path: string): Promise<string>;
     getConfig(): Promise<ArchivesConfig>;

package/storage/remoteStorage/ArchivesUrl.ts

@@ -1,5 +1,5 @@
 import { httpsRequest, HttpsResponseInfo } from "socket-function/src/https";
-import { IArchives, ArchiveFileInfo, ArchivesConfig, ChangesAfterConfig, GetConfig, GetInfoConfig } from "../IArchives";
+import { IArchives, ArchiveFileInfo, ArchivesConfig, ChangesAfterConfig, FindConfig, GetConfig, GetInfoConfig } from "../IArchives";
 import { buildFileUrl } from "./remoteConfig";
 
 // Read-only IArchives over a public bucket's plain-URL form (our storage server's
@@ -50,16 +50,18 @@ export class ArchivesUrl implements IArchives {
         }
         let lastModified = response.headers["last-modified"];
         let writeTime = lastModified && new Date(lastModified).getTime() || 0;
+        // A size-0 answer is a tombstone (backblaze friendly URLs serve deletions as real empty files; our own servers 404 them) - absent, unless the caller asked for tombstones. Ranged reads of a REAL file can legitimately return no bytes (range past EOF), which the total size distinguishes.
+        if (!size && !config?.includeTombstones) return undefined;
         return { data, writeTime, size };
     }
     public async getInfo(fileName: string, config?: GetInfoConfig): Promise<{ writeTime: number; size: number } | undefined> {
         // A 1-byte ranged read: Content-Range carries the full size and Last-Modified the write time, so metadata never downloads the file
         let result: { writeTime: number; size: number } | undefined;
         try {
-            result = await this.get2(fileName, { range: { start: 0, end: 1 } });
+            result = await this.get2(fileName, { range: { start: 0, end: 1 }, includeTombstones: config?.includeTombstones });
         } catch {
             // Some servers reject ranged reads of empty files (416 instead of an empty 206); a full read is the fallback, and for an empty file it is free anyway
-            result = await this.get2(fileName);
+            result = await this.get2(fileName, { includeTombstones: config?.includeTombstones });
         }
         if (!result) return undefined;
         if (!result.size && !config?.includeTombstones) return undefined;
@@ -75,10 +77,10 @@ export class ArchivesUrl implements IArchives {
     public async setLargeFile(config: { path: string; getNextData(): Promise<Buffer | undefined> }): Promise<void> {
         throw this.readOnlyError("setLargeFile");
     }
-    public async find(prefix: string, config?: { shallow?: boolean; type: "files" | "folders" }): Promise<string[]> {
+    public async find(prefix: string, config?: FindConfig): Promise<string[]> {
         throw this.readOnlyError("find (listing)");
     }
-    public async findInfo(prefix: string, config?: { shallow?: boolean; type: "files" | "folders" }): Promise<ArchiveFileInfo[]> {
+    public async findInfo(prefix: string, config?: FindConfig): Promise<ArchiveFileInfo[]> {
         throw this.readOnlyError("findInfo (listing)");
     }
     public async getChangesAfter2(config: ChangesAfterConfig): Promise<ArchiveFileInfo[]> {

package/storage/remoteStorage/accessPage.tsx

@@ -82,8 +82,8 @@ class AccessPage extends preact.Component {
     }
     private async refresh(account: string) {
         let controller = await this.controller();
-        await controller.requestAccess(account);
-        this.synced.state = await controller.getAccessState(account);
+        await controller.requestAccess({ account });
+        this.synced.state = await controller.getAccessState({ account });
         this.synced.error = "";
     }
 
@@ -94,7 +94,7 @@ class AccessPage extends preact.Component {
         this.synced.lookupError = "";
         try {
             let controller = await this.controller();
-            let requests = await controller.listRequestsForIP(this.synced.account, ip);
+            let requests = await controller.listRequestsForIP({ account: this.synced.account, ip });
             this.synced.lookupResults = { ip, requests };
         } catch (e) {
             this.synced.lookupError = String(e);
@@ -107,7 +107,7 @@ class AccessPage extends preact.Component {
         this.synced.granting = request.requestId;
         try {
             let controller = await this.controller();
-            await controller.grantAccess(request.requestId);
+            await controller.grantAccess({ requestId: request.requestId });
             if (this.synced.lookupResults) {
                 this.synced.lookupResults.requests = this.synced.lookupResults.requests.filter(r => r.requestId !== request.requestId);
             }

package/storage/remoteStorage/accessStats.d.ts

@@ -15,6 +15,8 @@ export declare function trackAccess(config: {
     path: string;
     size?: number;
 }): void;
+/** Method decorator factory, for API methods whose single config-object argument has account and bucketName: tracks the access (as `bucketName/path`) after the method succeeds. Sizes come from the config's data (writes) or the result's data (reads); operations without either are count-only. Array results (listings) track one access per returned path, or a single access at the prefix when empty. */
+export declare function trackAccessCall(operation: string): (target: unknown, key: string, descriptor: PropertyDescriptor) => void;
 export declare function getAccessTotals(account: string): AccessTotals;
 export declare function readAccessSummaries(config: {
     account: string;

package/storage/remoteStorage/accessStats.ts

@@ -57,6 +57,38 @@ export function trackAccess(config: { account: string; operation: string; path:
     }
 }
 
+/** Method decorator factory, for API methods whose single config-object argument has account and bucketName: tracks the access (as `bucketName/path`) after the method succeeds. Sizes come from the config's data (writes) or the result's data (reads); operations without either are count-only. Array results (listings) track one access per returned path, or a single access at the prefix when empty. */
+export function trackAccessCall(operation: string) {
+    return function (target: unknown, key: string, descriptor: PropertyDescriptor): void {
+        let original = descriptor.value as (...args: unknown[]) => Promise<unknown>;
+        descriptor.value = async function (...args: unknown[]): Promise<unknown> {
+            let config = args[0] as { account: string; bucketName: string; path?: string; prefix?: string; data?: Buffer };
+            let result = await original.apply(this, args);
+            let base = `${config.bucketName}/`;
+            if (Array.isArray(result)) {
+                if (result.length) {
+                    for (let entry of result as { path: string }[]) {
+                        trackAccess({ account: config.account, operation, path: base + entry.path });
+                    }
+                } else {
+                    // The paths are only known once the results are in; an empty result still counts as one access at the prefix
+                    trackAccess({ account: config.account, operation, path: base + (config.prefix || config.path || "") });
+                }
+                return result;
+            }
+            let size: number | undefined;
+            if (config.data) {
+                size = config.data.length;
+            } else {
+                let data = (result as { data?: Buffer } | undefined)?.data;
+                if (data) size = data.length;
+            }
+            trackAccess({ account: config.account, operation, path: base + config.path, size });
+            return result;
+        };
+    };
+}
+
 export function getAccessTotals(account: string): AccessTotals {
     let result: AccessTotals = {};
     let operations = accounts.get(account);

package/storage/remoteStorage/blobStore.d.ts

@@ -1,37 +1,46 @@
 /// <reference types="node" />
 /// <reference types="node" />
-import { IArchives, ArchiveFileInfo, ArchivesSource, ArchivesSyncStatus, ChangesAfterConfig, GetConfig, GetInfoConfig, SyncActivity } from "../IArchives";
+import { IArchives, ArchiveFileInfo, ArchivesSource, ArchivesSyncStatus, ChangesAfterConfig, FindConfig, HostedConfig, SyncActivity } from "../IArchives";
+import { ArchivesDisk } from "../ArchivesDisk";
 export declare const DEFAULT_FAST_WRITE_DELAY: number;
 export declare const WINDOW_END_FLUSH_MARGIN: number;
-export type WriteConfig = {
-    fast?: boolean;
-    writeDelay?: number;
-    lastModified?: number;
-};
 export type IBucketStore = {
-    get(fileName: string, config?: GetConfig): Promise<Buffer | undefined>;
-    get2(fileName: string, config?: GetConfig): Promise<{
+    /** internal (store-to-store) reads answer purely from the local disk; see GetConfig.internal */
+    get2(config: {
+        path: string;
+        range?: {
+            start: number;
+            end: number;
+        };
+        internal?: boolean;
+        includeTombstones?: boolean;
+    }): Promise<{
         data: Buffer;
         writeTime: number;
         size: number;
     } | undefined>;
-    getInternal2?(fileName: string, config?: GetConfig): Promise<{
+    /** internal (store-to-store) writes go to the local disk + index with no fan-out; see SetConfig.internal */
+    set(config: {
+        path: string;
         data: Buffer;
-        writeTime: number;
-        size: number;
-    } | undefined>;
-    setInternal?(fileName: string, data: Buffer, config: {
-        lastModified: number;
+        lastModified?: number;
+        forceSetImmutable?: boolean;
+        internal?: boolean;
+    }): Promise<void>;
+    del(config: {
+        path: string;
+        lastModified?: number;
+        internal?: boolean;
     }): Promise<void>;
-    set(fileName: string, data: Buffer, config?: WriteConfig): Promise<string>;
-    del(fileName: string, config?: WriteConfig): Promise<void>;
-    getInfo(fileName: string, config?: GetInfoConfig): Promise<{
+    getInfo(config: {
+        path: string;
+        includeTombstones?: boolean;
+    }): Promise<{
         writeTime: number;
         size: number;
     } | undefined>;
-    findInfo(prefix: string, config?: {
-        shallow?: boolean;
-        type?: "files" | "folders";
+    findInfo(config: FindConfig & {
+        prefix: string;
     }): Promise<ArchiveFileInfo[]>;
     getChangesAfter2(config: ChangesAfterConfig): Promise<ArchiveFileInfo[]>;
     getSyncStatus?(): Promise<ArchivesSyncStatus>;
@@ -57,11 +66,78 @@ export type IBucketStore = {
             byteCount: number;
         }[];
     }>;
-    startLargeUpload(): Promise<string>;
-    appendLargeUpload(id: string, data: Buffer): Promise<void>;
-    finishLargeUpload(id: string, key: string, lastModified?: number): Promise<void>;
-    cancelLargeUpload(id: string): Promise<void>;
+    /** path/lastModified let the store reject an upload into an immutable bucket before any bytes move */
+    startLargeUpload(config?: {
+        path?: string;
+        lastModified?: number;
+    }): Promise<string>;
+    appendLargeUpload(config: {
+        id: string;
+        data: Buffer;
+    }): Promise<void>;
+    finishLargeUpload(config: {
+        id: string;
+        path: string;
+        lastModified?: number;
+    }): Promise<void>;
+    cancelLargeUpload(config: {
+        id: string;
+    }): Promise<void>;
 };
+/** rawDisk buckets: the disk IS the store. No index, no synchronization, no window/route/immutability validation. */
+export declare class RawDiskStore implements IBucketStore {
+    private disk;
+    constructor(disk: ArchivesDisk);
+    get2(config: {
+        path: string;
+        range?: {
+            start: number;
+            end: number;
+        };
+        internal?: boolean;
+        includeTombstones?: boolean;
+    }): Promise<{
+        data: Buffer;
+        writeTime: number;
+        size: number;
+    } | undefined>;
+    set(config: {
+        path: string;
+        data: Buffer;
+        lastModified?: number;
+        forceSetImmutable?: boolean;
+        internal?: boolean;
+    }): Promise<void>;
+    del(config: {
+        path: string;
+        lastModified?: number;
+        internal?: boolean;
+    }): Promise<void>;
+    getInfo(config: {
+        path: string;
+        includeTombstones?: boolean;
+    }): Promise<{
+        writeTime: number;
+        size: number;
+    } | undefined>;
+    findInfo(config: FindConfig & {
+        prefix: string;
+    }): Promise<ArchiveFileInfo[]>;
+    getChangesAfter2(config: ChangesAfterConfig): Promise<ArchiveFileInfo[]>;
+    startLargeUpload(): Promise<string>;
+    appendLargeUpload(config: {
+        id: string;
+        data: Buffer;
+    }): Promise<void>;
+    finishLargeUpload(config: {
+        id: string;
+        path: string;
+        lastModified?: number;
+    }): Promise<void>;
+    cancelLargeUpload(config: {
+        id: string;
+    }): Promise<void>;
+}
 export type BlobSourceSpec = {
     identity: string;
     url: string;
@@ -80,47 +156,51 @@ export declare class BlobStore implements IBucketStore {
         readerDiskLimit?: number | undefined;
         onWriteCounted?: ((kind: "original" | "flushed", bytes: number) => void) | undefined;
         resolveSourceUrl?: ((url: string) => IArchives) | undefined;
+        entries?: HostedConfig[] | undefined;
     } | undefined);
-    private stopped;
-    private index;
-    private mem;
-    private indexFileCount;
-    private indexByteCount;
-    private sourceFileCounts;
-    private sourceByteCounts;
-    private syncActivities;
-    private dirty;
-    private overlay;
-    private sourceStates;
-    private syncStarted;
-    private sourcesList;
-    private slotSourcesListIndexes;
-    private slotRegistrations;
-    private isLive;
-    private registerSlot;
-    private sourcesListIndexOfSlot;
-    private slotForSourcesListIndex;
-    private getEntryHolder;
     init: {
         (): Promise<void>;
         reset(): void;
         set(newValue: Promise<void>): void;
     };
     dispose(): Promise<void>;
-    private loadIndex;
-    private countEntry;
-    private setIndexEntry;
-    private deleteIndexEntry;
-    /** Applies a config change to the RUNNING store: windows/routes update in place, new sources are added (their sync starts immediately), and removed sources' slots go dead (their scans stop, their index entries drop). The store survives every routine config evolution - it is never destroyed for a source-list change, only for structural flips it cannot express (rawDisk). Pending fast writes are re-capped to the new flush deadline (flushing immediately when it has already passed). */
-    updateSources(specs: BlobSourceSpec[]): void;
-    private removeSource;
-    /** Rescans our own disk's metadata into the index - used around valid window handoffs, where another process wrote files to the shared folder that our index hasn't seen. */
-    rescanBase(): Promise<void>;
-    /** A boundary scan of the node that owned (part of) our route in the valid window before ours, when that node is different storage (a disk rescan can't see its writes): just its changes since the boundary neighborhood, with matching values pulled onto our own disk. */
-    boundaryScanRemote(source: IArchives, config: {
-        since: number;
-        route?: [number, number];
+    get2(config: {
+        path: string;
+        range?: {
+            start: number;
+            end: number;
+        };
+        internal?: boolean;
+        includeTombstones?: boolean;
+    }): Promise<{
+        data: Buffer;
+        writeTime: number;
+        size: number;
+    } | undefined>;
+    set(config: {
+        path: string;
+        data: Buffer;
+        lastModified?: number;
+        forceSetImmutable?: boolean;
+        internal?: boolean;
     }): Promise<void>;
+    del(config: {
+        path: string;
+        lastModified?: number;
+        internal?: boolean;
+    }): Promise<void>;
+    getInfo(config: {
+        path: string;
+        includeTombstones?: boolean;
+    }): Promise<{
+        writeTime: number;
+        size: number;
+    } | undefined>;
+    findInfo(config: FindConfig & {
+        prefix: string;
+    }): Promise<ArchiveFileInfo[]>;
+    getChangesAfter2(config: ChangesAfterConfig): Promise<ArchiveFileInfo[]>;
+    getSyncStatus(): Promise<ArchivesSyncStatus>;
     /** The cheap always-current totals plus any in-progress background synchronization. */
     getSyncProgress(): {
         index: {
@@ -145,7 +225,60 @@ export declare class BlobStore implements IBucketStore {
             byteCount: number;
         }[];
     }>;
+    /** Applies a config change to the RUNNING store: windows/routes update in place, new sources are added (their sync starts immediately), and removed sources' slots go dead (their scans stop, their index entries drop). The store survives every routine config evolution - it is never destroyed for a source-list change, only for structural flips it cannot express (rawDisk). Pending fast writes are re-capped to the new flush deadline (flushing immediately when it has already passed). */
+    updateSources(specs: BlobSourceSpec[], entries?: HostedConfig[]): void;
+    /** Rescans our own disk's metadata into the index - used around valid window handoffs, where another process wrote files to the shared folder that our index hasn't seen. */
+    rescanBase(): Promise<void>;
+    /** A boundary scan of the node that owned (part of) our route in the valid window before ours, when that node is different storage (a disk rescan can't see its writes): just its changes since the boundary neighborhood, with matching values pulled onto our own disk. */
+    boundaryScanRemote(source: IArchives, config: {
+        since: number;
+        route?: [number, number];
+    }): Promise<void>;
+    startLargeUpload(config?: {
+        path?: string;
+        lastModified?: number;
+    }): Promise<string>;
+    appendLargeUpload(config: {
+        id: string;
+        data: Buffer;
+    }): Promise<void>;
+    finishLargeUpload(config: {
+        id: string;
+        path: string;
+        lastModified?: number;
+    }): Promise<void>;
+    cancelLargeUpload(config: {
+        id: string;
+    }): Promise<void>;
+    private stopped;
+    private index;
+    private mem;
+    private indexFileCount;
+    private indexByteCount;
+    private sourceFileCounts;
+    private sourceByteCounts;
+    private syncActivities;
+    private dirty;
+    private overlay;
+    private sourceStates;
+    private syncStarted;
+    private entries;
+    private sourcesList;
+    private slotSourcesListIndexes;
+    private slotRegistrations;
+    private isLive;
+    private registerSlot;
+    private sourcesListIndexOfSlot;
+    private slotForSourcesListIndex;
+    private getEntryHolder;
+    private loadIndex;
+    private countEntry;
+    private setIndexEntry;
+    private deleteIndexEntry;
+    private removeSource;
     private flushIndex;
+    private assertMutable;
+    private assertInternalWriteAccepted;
     private runSourceSync;
     private isDeadIntermediate;
     private scanSource;
@@ -156,43 +289,15 @@ export declare class BlobStore implements IBucketStore {
     private waitForRequiredScans;
     private checkMissingKey;
     private getIndexEntry;
-    get(key: string, config?: GetConfig): Promise<Buffer | undefined>;
-    get2(key: string, config?: GetConfig): Promise<{
-        data: Buffer;
-        writeTime: number;
-        size: number;
-    } | undefined>;
     /** Internal (store-to-store) read: purely the local disk, completely short-circuiting the index and holder resolution - the caller is another store, and chasing OUR remote holders while answering it is how infinite get loops between stores form. No window or route checks: if the bytes are on our disk, the caller may have them. Note fast writes still sitting in the overlay are invisible here; the caller re-finds them after our flush. */
-    getInternal2(key: string, config?: GetConfig): Promise<{
-        data: Buffer;
-        writeTime: number;
-        size: number;
-    } | undefined>;
-    /** Internal (store-to-store) write: the local disk plus our index, with NO downstream fan-out - the pushing store owns propagation, and fanning its pushes back out is how write loops between stores form. Window/route acceptance is the caller's (writeBucketFile's) job; only-take-latest still applies here. */
-    setInternal(key: string, data: Buffer, config: {
-        lastModified: number;
-    }): Promise<void>;
+    private getInternal2;
+    /** Internal (store-to-store) write: the local disk plus our index, with NO downstream fan-out - the pushing store owns propagation, and fanning its pushes back out is how write loops between stores form. Only-take-latest still applies here. */
+    private setInternal;
     private cacheRead;
-    set(key: string, data: Buffer, config?: WriteConfig): Promise<string>;
-    del(key: string, config?: WriteConfig): Promise<void>;
     private setOrDelete;
     private getWritableSources;
     private writeToSources;
-    getInfo(key: string, config?: GetInfoConfig): Promise<{
-        writeTime: number;
-        size: number;
-    } | undefined>;
-    findInfo(prefix: string, config?: {
-        shallow?: boolean;
-        type?: "files" | "folders";
-    }): Promise<ArchiveFileInfo[]>;
-    getChangesAfter2(config: ChangesAfterConfig): Promise<ArchiveFileInfo[]>;
-    getSyncStatus(): Promise<ArchivesSyncStatus>;
     private getDiskSource;
-    startLargeUpload(): Promise<string>;
-    appendLargeUpload(id: string, data: Buffer): Promise<void>;
-    finishLargeUpload(id: string, key: string, lastModified?: number): Promise<void>;
-    cancelLargeUpload(id: string): Promise<void>;
     private flushOverlay;
     private evicting;
     private enforceDiskLimit;