sliftutils 1.7.87 → 1.7.89

package/storage/remoteStorage/ArchivesUrl.ts

@@ -1,5 +1,5 @@
 import { httpsRequest, HttpsResponseInfo } from "socket-function/src/https";
-import { IArchives, ArchiveFileInfo, ArchivesConfig, ChangesAfterConfig, FindConfig, GetConfig, GetInfoConfig } from "../IArchives";
+import { IArchives, ArchiveFileInfo, ArchivesConfig, ChangesAfterConfig, FindConfig, GetConfig, GetInfoConfig, SetLargeFileConfig } from "../IArchives";
 import { buildFileUrl } from "./remoteConfig";
 
 // Read-only IArchives over a public bucket's plain-URL form (our storage server's
@@ -74,7 +74,7 @@ export class ArchivesUrl implements IArchives {
     public async del(fileName: string): Promise<void> {
         throw this.readOnlyError("del");
     }
-    public async setLargeFile(config: { path: string; getNextData(): Promise<Buffer | undefined> }): Promise<void> {
+    public async setLargeFile(config: SetLargeFileConfig): Promise<void> {
         throw this.readOnlyError("setLargeFile");
     }
     public async find(prefix: string, config?: FindConfig): Promise<string[]> {

package/storage/remoteStorage/accessPage.tsx

@@ -204,8 +204,20 @@ class AccessPage extends preact.Component {
     }
 }
 
+// Reached via the cert-trust flow (showCertTrustModal links here as ?trustCert=1). The browser only loads this page if it has ACCEPTED the certificate - so the mere fact that it rendered is the confirmation. Once accepted, the app's background connection to this same server works, so the user just returns.
+function CertTrustedPage() {
+    return <div className={css.vbox(8).pad2(16)}>
+        <div>This server's certificate is now trusted by this browser.</div>
+        <div>Close this tab and return to the page you came from - it will connect to the storage server automatically.</div>
+    </div>;
+}
+
 async function main() {
     if (isNode()) return;
+    if (new URLSearchParams(location.search).has("trustCert")) {
+        preact.render(<CertTrustedPage />, document.body);
+        return;
+    }
     preact.render(<AccessPage />, document.body);
 }
 

package/storage/remoteStorage/accessStats.d.ts

@@ -15,7 +15,7 @@ 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 - findInfo, getChangesAfter) are tracked as two count-only operations: "<op> queries" at the query prefix (one per call), and "<op> results" at each returned path (one per result). */
+/** 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 - findInfo, getChangesAfter) are tracked as two breakdowns: "<op> queries" - one access per CALL, at the query prefix, sized by the number of results (so the tree shows which QUERY returns the most) - and "<op> results" - one count-only access per returned path (so the tree shows which PATHS come back most). */
 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: {

package/storage/remoteStorage/accessStats.ts

@@ -57,7 +57,7 @@ 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 - findInfo, getChangesAfter) are tracked as two count-only operations: "<op> queries" at the query prefix (one per call), and "<op> results" at each returned path (one per result). */
+/** 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 - findInfo, getChangesAfter) are tracked as two breakdowns: "<op> queries" - one access per CALL, at the query prefix, sized by the number of results (so the tree shows which QUERY returns the most) - and "<op> results" - one count-only access per returned path (so the tree shows which PATHS come back most). */
 export function trackAccessCall(operation: string) {
     return function (target: unknown, key: string, descriptor: PropertyDescriptor): void {
         let original = descriptor.value as (...args: unknown[]) => Promise<unknown>;
@@ -66,8 +66,8 @@ export function trackAccessCall(operation: string) {
             let result = await original.apply(this, args);
             let base = `${config.bucketName}/`;
             if (Array.isArray(result)) {
-                // Two separate breakdowns, both count-only: WHAT was queried, and WHAT was returned
-                trackAccess({ account: config.account, operation: `${operation} queries`, path: base + (config.prefix || config.path || "") });
+                // The query, sized by how many results it returned (which query is heaviest); and each returned path, count-only (which paths come back most)
+                trackAccess({ account: config.account, operation: `${operation} queries`, path: base + (config.prefix || config.path || ""), size: result.length });
                 for (let entry of result as { path: string }[]) {
                     trackAccess({ account: config.account, operation: `${operation} results`, path: base + entry.path });
                 }

package/storage/remoteStorage/blobStore.d.ts

@@ -1,143 +1,19 @@
 /// <reference types="node" />
 /// <reference types="node" />
-import { IArchives, ArchiveFileInfo, ArchivesSource, ArchivesSyncStatus, ChangesAfterConfig, FindConfig, HostedConfig, SourceConfig, SyncActivity } from "../IArchives";
-import { ArchivesDisk } from "../ArchivesDisk";
-export declare const DEFAULT_FAST_WRITE_DELAY: number;
+import { IArchives, ArchiveFileInfo, ArchivesSource, ArchivesSyncStatus, ChangesAfterConfig, FindConfig, SourceConfig, SyncActivity } from "../IArchives";
+import { StoreSync } from "./storeSync";
+import { StoreConfig } from "./storeConfig";
 export declare const WINDOW_END_FLUSH_MARGIN: number;
-export type IBucketStore = {
-    /** 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>;
-    /** internal (store-to-store) writes go to the local disk + index with no fan-out; see SetConfig.internal */
-    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>;
-    getSyncProgress?(): {
-        index: {
-            fileCount: number;
-            byteCount: number;
-        };
-        sources: {
-            debugName: string;
-            fileCount: number;
-            byteCount: number;
-        }[];
-        readerDiskLimit?: number;
-        syncing: SyncActivity[];
-    };
-    computeIndexTotals?(): Promise<{
-        fileCount: number;
-        byteCount: number;
-        sources: {
-            debugName: string;
-            fileCount: number;
-            byteCount: number;
-        }[];
-    }>;
-    /** 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>;
+/** What we store about a file. Its times are not in here: the index keeps those for every key, deleted ones included (see LogMap). */
+type IndexValue = {
+    size: number;
+    sourcesListIndex: number;
+};
+/** One file we hold, as everything outside the index sees it. */
+export type IndexEntry = IndexValue & {
+    writeTime: number;
+    changedAt: number;
 };
-/** 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;
@@ -147,23 +23,69 @@ export type BlobSourceSpec = {
     intermediate?: string;
     sourceConfig?: SourceConfig;
     create: () => IArchives;
+    applyConfig?: (source: IArchives) => void;
 };
-export declare class BlobStore implements IBucketStore {
-    private folder;
-    private sources;
+export declare class BlobStore {
+    folder: string;
+    /** The name this store answers to (see CommonConfig.name) - the entries of the routing config that carry it are the ones that configure it, and the rest are its peers. */
+    storeName: string;
     private config?;
-    constructor(folder: string, sources: ArchivesSource[], config?: {
+    stopped: {
+        stop: boolean;
+    };
+    syncStarted: boolean;
+    /** Its sources, in config order: slot 0 is always its own disk folder, the rest are the peers it synchronizes with. Filled by updateSources, which is also how they change. The store OWNS them - writes pick among them, reads resolve holders through them - and StoreSync only scans whatever is in here at the time. */
+    sources: ArchivesSource[];
+    private discardedUploads;
+    private nextDiscardedUpload;
+    private sourcesList;
+    private slotSourcesListIndexes;
+    private slotRegistrations;
+    private index;
+    /** Keeping the index in agreement with the sources: scanning, pulling, pushing, and the maintenance that follows from holding an index (disk-limit eviction, tombstone expiry). It reads and writes this store's index and sources - it does not own them. */
+    sync: StoreSync;
+    constructor(folder: string, 
+    /** The name this store answers to (see CommonConfig.name) - the entries of the routing config that carry it are the ones that configure it, and the rest are its peers. */
+    storeName: string, config?: {
+        /** Whether a config entry is THIS SERVER (same account, same bucket, our own address). Injected because a store knows nothing about servers - it only needs to tell its own entries apart from its peers'. Absent means nothing is us, which is what a bare store (no server around it) wants. */
+        isSelf?: ((source: SourceConfig) => boolean) | undefined;
+        /** Builds one of its sources. Injected for the same reason, and because the delay it is created with is this store's policy. */
+        createSource?: ((config: {
+            sourceConfig?: SourceConfig;
+            writeDelay: number;
+        }) => IArchives) | undefined;
+        /** Hands a running source a changed config, so an endpoint we already talk to is never rebuilt just because a flag moved. */
+        applySource?: ((source: IArchives, sourceConfig: SourceConfig | undefined, writeDelay: number) => void) | undefined;
         onIndexChanged?: ((key: string) => void) | undefined;
-        readerDiskLimit?: number | undefined;
         onWriteCounted?: ((kind: "original" | "flushed", bytes: number) => void) | undefined;
         resolveSourceUrl?: ((url: string) => IArchives) | undefined;
-        entries?: HostedConfig[] | undefined;
     } | undefined);
+    /** This store's folder, unwrapped: the same bytes slot 0 serves, but reached without its write delay. Used for the two things that cannot go through a buffered source - reading our own routing config before we have any sources, and streaming a large upload that must not sit in memory. */
+    private ownDisk;
+    /** What this store is configured to be. It owns this: the routing config is a file IN the store, so the store reads it, applies it to itself, and re-applies it whenever the file changes - by our own write, or by a peer's copy arriving through synchronization. */
+    storeConfig: StoreConfig;
+    private appliedRoutingVersion;
     init: {
         (): Promise<void>;
         reset(): void;
         set(newValue: Promise<void>): void;
     };
+    /**
+     * Re-reads the routing config out of this store and applies it to itself. Called at startup and
+     * whenever that file changes here - which is the ONE mechanism: a config written by an operator
+     * and a config pulled off a peer are the same event, a write of that path into this store.
+     *
+     * A store with no routing config configures itself as its own disk, valid always, for the whole
+     * key space. That is a complete, working store - it just has nobody to synchronize with - and it
+     * is what lets a store exist before it has ever heard of a configuration.
+     */
+    applyRoutingConfig(): Promise<void>;
+    private readRoutingConfig;
+    /** The version of the routing config this store is running, so a copy found on a peer is only taken when it is genuinely newer. -1 means it has none. */
+    routingVersion(): number;
+    private routingApplies;
+    reapplyRoutingConfig(): void;
+    private planSources;
     dispose(): Promise<void>;
     get2(config: {
         path: string;
@@ -190,6 +112,11 @@ export declare class BlobStore implements IBucketStore {
         lastModified?: number;
         internal?: boolean;
     }): Promise<void>;
+    /** A node-side move: the bytes never travel through the client. Deliberately just get2 + set + del rather than a disk rename, so the destination write passes EVERY rule a set passes (windows, routes, immutability, only-take-latest, index, fan-out to peers) and the deletion propagates as a normal tombstone - a rename would bypass all of it. The set stamps fresh, so the moved file beats any tombstone at its new path. */
+    move(config: {
+        fromPath: string;
+        toPath: string;
+    }): Promise<void>;
     getInfo(config: {
         path: string;
         includeTombstones?: boolean;
@@ -202,7 +129,7 @@ export declare class BlobStore implements IBucketStore {
     }): Promise<ArchiveFileInfo[]>;
     getChangesAfter2(config: ChangesAfterConfig): Promise<ArchiveFileInfo[]>;
     getSyncStatus(): Promise<ArchivesSyncStatus>;
-    /** The cheap always-current totals plus any in-progress background synchronization. */
+    /** The index's totals plus any in-progress background synchronization. */
     getSyncProgress(): {
         index: {
             fileCount: number;
@@ -216,7 +143,7 @@ export declare class BlobStore implements IBucketStore {
         readerDiskLimit?: number;
         syncing: SyncActivity[];
     };
-    /** Walks the whole index for exact totals - more expensive than getSyncProgress, but immune to any drift in the maintained counters (and loads the index first, so it's never cold zeros). */
+    /** getSyncProgress's totals, but loading the index first, so they are never the zeroes of a store nothing has touched yet. */
     computeIndexTotals(): Promise<{
         fileCount: number;
         byteCount: number;
@@ -226,11 +153,22 @@ 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;
+    private namedIndexTotals;
+    /**
+     * The store's sources, as the current routing config says they should be. This is the ONLY way
+     * they are ever set: the first call populates an empty store, every later one applies a change to
+     * the running one. Windows, routes and flags move in place, genuinely new endpoints are added and
+     * start scanning, and endpoints that are gone go dead (their scans stop, their index entries
+     * drop).
+     *
+     * A store is never rebuilt for a config change. Its name decides its folder and its identity, and
+     * a config change cannot change either - so there is nothing a change can do to a store except
+     * this.
+     */
+    updateSources(specs: BlobSourceSpec[]): 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. */
+    /** 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). */
     boundaryScanRemote(source: IArchives, config: {
         since: number;
         route?: [number, number];
@@ -238,6 +176,9 @@ export declare class BlobStore implements IBucketStore {
     startLargeUpload(config?: {
         path?: string;
         lastModified?: number;
+        forceSetImmutable?: boolean;
+        noChecks?: boolean;
+        internal?: boolean;
     }): Promise<string>;
     appendLargeUpload(config: {
         id: string;
@@ -247,62 +188,94 @@ export declare class BlobStore implements IBucketStore {
         id: string;
         path: string;
         lastModified?: number;
+        forceSetImmutable?: boolean;
+        noChecks?: boolean;
+        internal?: boolean;
     }): 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;
+    /** Bytes of read cache the disk may hold; see CommonConfig.readerDiskLimit (StoreSync enforces it). Read from the config in effect, so raising or removing the limit takes effect on the next eviction pass. */
+    get readerDiskLimit(): number | undefined;
+    /** The write time a new write has to beat, or 0 when we have never heard of the key. Counts DELETIONS too: a write older than the deletion that removed it must not bring it back. The index is authoritative even for a write still buffered in a delayed source, since the entry is recorded when the write is accepted rather than when it reaches storage. */
+    currentWriteTime(key: string): number;
     private isLive;
-    private registerSlot;
-    private sourcesListIndexOfSlot;
-    private slotForSourcesListIndex;
-    private getEntryHolder;
+    registerSlot(slot: number): Promise<void>;
+    /** The persistent sourcesListIndex of a slot, or undefined when the slot never got that far (a source removed before its registration resolved). */
+    slotSourcesListIndex(slot: number): number | undefined;
+    sourcesListIndexOfSlot(slot: number): number;
+    slotForSourcesListIndex(sourcesListIndex: number): number | undefined;
+    getEntryHolder(entry: IndexEntry): Promise<IArchives | undefined>;
     private loadIndex;
-    private countEntry;
-    private setIndexEntry;
-    private deleteIndexEntry;
-    private removeSource;
-    private flushIndex;
+    /** A file we hold. A deleted one is not one: it is a tombstone, and only getDeletedEntry knows about it. */
+    getIndexEntry(key: string): IndexEntry | undefined;
+    /** When a key was deleted, if it was. A deletion is an absence with a time attached - that time is what makes it propagate and what expires it. */
+    getDeletedEntry(key: string): {
+        writeTime: number;
+        changedAt: number;
+    } | undefined;
+    /** Every file we hold, for the passes that walk them all (listings, scans, reconciliation, eviction). Deletions are not in here - see deletedEntries. Live: deleting entries while iterating is expected here, and safe. */
+    indexEntries(): IterableIterator<[string, IndexEntry]>;
+    /** Every deletion we know of. A much smaller walk than the files, which is what makes expiring them cheap. */
+    deletedEntries(): IterableIterator<[string, {
+        writeTime: number;
+        changedAt: number;
+    }]>;
+    /** How many files we hold, deletions excluded. */
+    indexSize(): number;
+    /** Totals over the files we hold, broken down by the slot holding each (entries can name a source that is no longer configured, which counts towards the total but no slot). */
+    indexTotals(): {
+        fileCount: number;
+        byteCount: number;
+        slots: {
+            fileCount: number;
+            byteCount: number;
+        }[];
+    };
+    /** Records a file, as of its write time. Returns false, having changed nothing, when we already know something at least as new - the index cannot be made to go backwards, whichever path the write came in by. */
+    setIndexEntry(key: string, entry: {
+        writeTime: number;
+        size: number;
+        sourcesListIndex: number;
+    }): boolean;
+    /** Records a DELETION, as of its time: the key stops existing here, and the tombstone is what makes that fact propagate and reconcile like any other write. Same ordering rule as setIndexEntry. */
+    setIndexDeleted(key: string, writeTime: number): boolean;
+    /** Forgets a key entirely, tombstone included. NOT a deletion: it says nothing happened to the file, only that we no longer know anything about it - for an entry whose holder turned out not to have it, and for a tombstone old enough that everyone has heard. */
+    purgeIndexEntry(key: string): void;
+    /**
+     * Every write, however it is stamped, has to be one we are actually meant to hold - because the
+     * alternative is not a smaller problem, it is a silent one. A write that lands on a store that
+     * does not serve its route (or on a server that is not in the bucket's config at all) goes into a
+     * folder nothing scans and no peer reconciles: it succeeds, and then it is gone. The markers make
+     * the client re-read the routing config and retry, which is exactly the right outcome when the
+     * reason it aimed here is that its config was stale.
+     */
+    private assertWriteTarget;
+    /**
+     * Whether a routing config may be written here. Two rules, and this is the one place either is
+     * applied - a config only ever enters the system through a write, so a config that got in is a
+     * config that passed, and reading one back never judges it again.
+     *
+     * The config has to be valid as a whole (see assertValidRemoteConfig), and it has to outrank what
+     * we are running: the same version means the same config, so re-writing it is harmless, but a
+     * lower one is an older config arriving late and must never undo a newer one.
+     */
+    private assertRoutingConfigWritable;
+    private assertFreshWriteTarget;
     private assertMutable;
     private assertInternalWriteAccepted;
-    private runSourceSync;
-    private isDeadIntermediate;
-    private scanSource;
-    private reconcileSource;
-    private updateScanIndex;
-    private pollChanges;
-    private copySourceFiles;
-    private waitForRequiredScans;
-    private checkMissingKey;
-    private getIndexEntry;
-    /** 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. */
+    /** 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 this reads the disk past any write delay, so a fast write still buffered in memory is invisible here; the caller re-finds it once it flushes. */
     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;
     private setOrDelete;
-    private baseWriteWindowEnd;
+    /** The instant every delayed write must be on its source: the end of our own write window that contains now, minus the flush margin (so the next window's source finds the data on handoff). The LATEST end among covering windows - overlapping windows hand off at the last one. No window contains now (an inert store, or a moment between our windows) -> 0, i.e. nothing may be delayed at all. */
+    writeFlushDeadline(): number;
     private getWritableSources;
     private writeToSources;
     private getDiskSource;
-    private isRemoteSource;
-    private flushOverlay;
-    private evicting;
-    private enforceDiskLimit;
-    private cleanupTombstones;
+    /** Writes everything still held by a delayed source (see ArchivesDelayed). force also writes what isn't due yet - shutdown cannot leave writes in memory. */
+    private flushDelayedWrites;
 }
+export {};