sliftutils 1.7.32 → 1.7.34

package/builders/extensionBuild.ts

@@ -8,7 +8,7 @@ import { getAllFiles } from "../misc/fs";
 
 async function main() {
     let time = Date.now();
-    //todonext
+    // todonext
     // We need to build both the extBackground.ts and extContentScript.ts
     // And copy the manifest.json
     // AND copy everything in ./assets which has updated

package/bundler/bundleEntry.ts

@@ -41,9 +41,7 @@ async function main() {
         entryPoints: [entryPoint],
     });
 
-    // Two artifacts: `name.js` without the sourcemap (the sourcemap is usually bigger than the code
-    // itself, so this is what production serves) and `name.debug.js` with the inline sourcemap
-    // appended (serve it behind something like a ?debug query param).
+    // Two artifacts: `name.js` without the sourcemap (the sourcemap is usually bigger than the code itself, so this is what production serves) and `name.debug.js` with the inline sourcemap appended (serve it behind something like a ?debug query param).
     async function write(finalPath: string, contents: string) {
         let tempPath = `${finalPath}.tmp`;
         try {

package/bundler/bundler.ts

@@ -9,11 +9,9 @@ export async function bundle(config: {
     rootPath: string;
     entryPoints: string[];
 }): Promise<{
-    // The runnable bundle, WITHOUT the sourcemap comment (the sourcemap is usually bigger than the
-    // code itself, so the default artifact ships without it).
+    // The runnable bundle, WITHOUT the sourcemap comment (the sourcemap is usually bigger than the code itself, so the default artifact ships without it).
     bundle: string;
-    // The trailing inline-sourcemap line comment. Append to `bundle` (with a newline) for the debug
-    // variant of the bundle.
+    // The trailing inline-sourcemap line comment. Append to `bundle` (with a newline) for the debug variant of the bundle.
     sourceMapComment: string;
 }> {
     const { modules, rootPath, entryPoints } = config;

package/bundler/sourceMaps.ts

@@ -38,8 +38,7 @@ export function removeSourceMap(content: string): {
     }
 
     let sourceMapJson = Buffer.from(match[1], "base64").toString();
-    // HACK: If the sourcemap is invalid, try to remove trailing characters. For some reason we sometimes have
-    //  extra characters at the end? Also try to add some characters too?
+    // HACK: If the sourcemap is invalid, try to remove trailing characters. For some reason we sometimes have extra characters at the end? Also try to add some characters too?
     function isJSON(str: string): boolean {
         try {
             JSON.parse(str);

package/examplestorage/browser.tsx

@@ -12,8 +12,7 @@ import { redButton, greenButton, errorMessage } from "../render-utils/colors";
 import { createArchives } from "../storage/remoteStorage/createArchives";
 import { ArchiveFileInfo } from "../storage/IArchives";
 
-// The bucket's routing URL: server, account ("example"), and bucket ("examplefiles") in one.
-// Nothing else is needed - the first call creates the bucket if it doesn't exist yet.
+// The bucket's routing URL: server, account ("example"), and bucket ("examplefiles") in one. Nothing else is needed - the first call creates the bucket if it doesn't exist yet.
 const STORAGE_URL = "https://storage.vidgridweb.com:4444/file/example/examplefiles/storage/storagerouting.json";
 const ACCESS_CHECK_INTERVAL = 1000 * 15;
 

package/examplestorage/exampleserver.ts

@@ -6,8 +6,7 @@ import { hostServer } from "../misc/https/hostServer";
 // Import browser code, so it is allowed to be required by the client
 import "./browser";
 
-// Static example site for the remote storage system (storage/remoteStorage). The browser talks to
-// the storage server directly, so this server only serves the page.
+// Static example site for the remote storage system (storage/remoteStorage). The browser talks to the storage server directly, so this server only serves the page.
 
 const DOMAIN = "storageexample.vidgridweb.com";
 const PORT = 4445;

package/index.d.ts

@@ -184,10 +184,7 @@ declare module "sliftutils/misc/https/dns" {
         modified_on: string;
         comment?: string | undefined;
     }[]>;
-    /** Cloudflare's batch endpoint applies deletes, then patches, then posts in a single database
-     *   transaction. We route edits (patches) through here because the standalone PATCH/PUT verbs
-     *   aren't usable in our setup, and because it lets "remove others + assert target" happen
-     *   without a window where the name resolves to nothing. */
+    /** Cloudflare's batch endpoint applies deletes, then patches, then posts in a single database transaction. We route edits (patches) through here because the standalone PATCH/PUT verbs aren't usable in our setup, and because it lets "remove others + assert target" happen without a window where the name resolves to nothing. */
     export declare function batchRecords(zoneId: string, batch: {
         deletes?: {
             id: string;
@@ -227,6 +224,8 @@ declare module "sliftutils/misc/https/hostServer" {
         portFallback?: {
             /** Delay until the next main-port acquisition attempt (tightened around the predecessor's scheduled death) */
             getAcquireDelay: () => number;
+            /** Called when the main port turned out to be busy, before we act as its successor in any way. Throwing aborts startup - a busy port with no deploy in progress means something else holds it, which is not a state to keep running in. */
+            onPortInUse?: () => Promise<void>;
             /** Reports every port we become reachable on (the alternate at mount, the main port once relayed) */
             onListening: (port: number, isMainPort: boolean) => void;
         };
@@ -1075,8 +1074,7 @@ declare module "sliftutils/storage/BulkDatabase2/BulkDatabase2" {
          * "someone else is already merging".
          */
         tryMergeNow(): Promise<MergeAttemptResult>;
-        /** Rewrite everything written in [timeLo, timeHi] into fresh key-sorted bulk file(s). Low-level;
-         * most callers want compact() or tryMergeNow(). */
+        /** Rewrite everything written in [timeLo, timeHi] into fresh key-sorted bulk file(s). Low-level; most callers want compact() or tryMergeNow(). */
         merge(timeLo: number, timeHi: number): Promise<void>;
     }
     export declare class MobxReactiveDeps implements ReactiveDeps {
@@ -2131,11 +2129,12 @@ declare module "sliftutils/storage/IArchives" {
         validWindow: [number, number];
         /** Sharding: the fraction of the key space this source handles, as [start, end) over [0, 1) (keys are routed by getRoute in remoteConfig.ts). Defaults to FULL_ROUTE (unsharded). At every point in time the sources' routes must fully cover [0, 1), or some keys could never be read. */
         route?: [number, number];
+        /** Set on entries injected into the in-memory config by an overlay (a deploy switchover's alternate-port window). Never written to disk: resolveIntermediateSources strips these and rejoins the windows around them, which is also how a client tells whether an update is a real configuration change or just an overlay. */
+        intermediate?: boolean;
     };
     export type HostedConfig = CommonConfig & {
         type: "remote";
         url: string;
-        accountName?: string;
         public?: boolean;
         fast?: boolean;
         writeDelay?: number;
@@ -2207,8 +2206,7 @@ declare module "sliftutils/storage/IArchives" {
     };
     export interface IArchives {
         getDebugName(): string;
-        /** Whether writes would be accepted (credentials exist, the account trusts this machine, etc).
-         *  Checked without writing anything. */
+        /** Whether writes would be accepted (credentials exist, the account trusts this machine, etc). Checked without writing anything. */
         hasWriteAccess(): Promise<boolean>;
         get(fileName: string, config?: {
             range?: {
@@ -2846,7 +2844,6 @@ declare module "sliftutils/storage/remoteStorage/ArchivesRemote" {
     import { IArchives, ArchiveFileInfo, ArchivesConfig, ArchivesSyncStatus } from "../IArchives";
     export type ArchivesRemoteConfig = {
         url: string;
-        accountName?: string;
         waitForAccess?: boolean;
     };
     export declare function parseStorageUrl(url: string): {
@@ -2872,9 +2869,7 @@ declare module "sliftutils/storage/remoteStorage/ArchivesRemote" {
         private lastDeniedLog;
         getDebugName(): string;
         isConnected(): boolean;
-        ping(): Promise<{
-            takeover?: string;
-        }>;
+        ping(): Promise<{}>;
         private authenticate;
         private callAuthed;
         waitingForAccess(): Promise<{
@@ -3067,6 +3062,7 @@ declare module "sliftutils/storage/remoteStorage/blobStore" {
         constructor(folder: string, sources: ArchivesSource[], config?: {
             onIndexChanged?: ((key: string) => void) | undefined;
             readerDiskLimit?: number | undefined;
+            onWriteCounted?: ((kind: "original" | "flushed", bytes: number) => void) | undefined;
         } | undefined);
         private stopped;
         private index;
@@ -3091,20 +3087,12 @@ declare module "sliftutils/storage/remoteStorage/blobStore" {
         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). */
+        /** 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. */
+        /** 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): just its changes since the boundary neighborhood, with matching values pulled onto our own disk. */
         boundaryScanRemote(source: IArchives, config: {
             since: number;
             route?: [number, number];
@@ -3123,8 +3111,7 @@ declare module "sliftutils/storage/remoteStorage/blobStore" {
             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). */
+        /** 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). */
         computeIndexTotals(): Promise<{
             fileCount: number;
             byteCount: number;
@@ -3197,7 +3184,9 @@ declare module "sliftutils/storage/remoteStorage/createArchives" {
     /// <reference types="node" />
     /// <reference types="node" />
     import { IArchives, RemoteConfig, RemoteConfigBase, HostedConfig, BackblazeConfig, ArchiveFileInfo, ArchivesConfig, ArchivesSyncStatus } from "../IArchives";
-    import { ServerBucketInfo } from "./storageServerState";
+    import { ServerBucketInfo, ActiveBucketInfo } from "./storageServerState";
+    /** The address, port, account, and bucket name a bucket routing URL addresses. Throws when the URL isn't a hosted bucket routing URL (https://host:port/file/<account>/<bucketName>/storage/storagerouting.json). */
+    export { parseHostedUrl, parseBackblazeUrl, getBucketBaseUrl } from "./remoteConfig";
     export declare function createApiArchives(source: HostedConfig | BackblazeConfig): IArchives;
     export declare class ArchivesChain implements IArchives {
         private configured;
@@ -3267,12 +3256,7 @@ declare module "sliftutils/storage/remoteStorage/createArchives" {
         getChangesAfter(time: number): Promise<ArchiveFileInfo[]>;
         getSyncStatus(): Promise<ArchivesSyncStatus>;
         getConfig(): Promise<ArchivesConfig>;
-        /** True only when EVERY write-receiving source would accept our writes (partial write access
-         *  desynchronizes sources, so it counts as no access). */
         hasWriteAccess(): Promise<boolean>;
-        /** Returns the full key written. Plain keys come back unchanged; keys containing VARIABLE_SHARD
-         *  are automatically materialized (a shard value is picked and embedded, see setVariableShard)
-         *  and the caller needs the returned key to ever read the value back. */
         set(fileName: string, data: Buffer, config?: {
             lastModified?: number;
         }): Promise<string>;
@@ -3287,58 +3271,55 @@ declare module "sliftutils/storage/remoteStorage/createArchives" {
         dispose(): void;
     }
     export declare function createArchives(config: RemoteConfig | RemoteConfigBase): ArchivesChain;
-    /** Every bucket an account has on one storage server - active and inactive - with each bucket's
-     *  configuration. One authenticated call (the normal trust system applies): no ArchivesChain, no
-     *  synchronization, and inactive buckets on the server stay inactive. Any URL addressing the
-     *  server works (a bucket routing URL, or just https://host:port). */
     export declare function listServerBuckets(config: {
         url: string;
         account: string;
     }): Promise<ServerBucketInfo[]>;
-    /** Live info for one bucket given its routing URL (getConfig: routing config, index totals, disk
-     *  limit, in-progress synchronization). One authenticated call to that server - a light, safe
-     *  alternative to instantiating an ArchivesChain, which would start synchronization machinery. */
+    /** The live, in-memory state of one bucket on a server (routing config included), or a string saying why it is unavailable. Cheap - it never touches the server's disk - but only works while that bucket is loaded there. */
+    export declare function getServerActiveBucket(config: {
+        url: string;
+        account: string;
+        bucketName: string;
+    }): Promise<ActiveBucketInfo | string>;
+    /** Tells a server to load one of its buckets into memory (starting its synchronization) and returns its live state, or a string saying why it could not be loaded. Only touches that server - nothing is written and no other source is contacted. */
+    export declare function activateServerBucket(config: {
+        url: string;
+        account: string;
+        bucketName: string;
+    }): Promise<ActiveBucketInfo | string>;
+    /** Zeroes the write statistics listServerBuckets reports, for every bucket in the account. */
+    export declare function clearServerWriteStats(config: {
+        url: string;
+        account: string;
+    }): Promise<{
+        clearedBuckets: number;
+    }>;
     export declare function getBucketInfo(config: {
         url: string;
-        accountName?: string;
     }): Promise<ArchivesConfig>;
 
 }
 
 declare module "sliftutils/storage/remoteStorage/deployTakeover" {
-    import { RemoteConfig } from "../IArchives";
-    export type TakeoverEvent = "remapChanged";
-    /** Starts the takeover machinery. Port fallback (alternate port + registry + acquisition polling)
-     *  works regardless; without a deploy timeline folder the switchover-specific parts (the remap,
-     *  the tighter acquisition pacing) simply stay inert. */
-    export declare function initDeployTakeover(config: {
-        domain: string;
-        mainPort: number;
-        storageFolder: string;
-    }): Promise<void>;
-    /** Called when we had to listen on an alternate port (the main port was still held by our
-     *  predecessor): registers it so the predecessor can route the middle overlap window to us. */
-    export declare function registerAltPort(port: number): Promise<void>;
-    export declare function onTakeoverEvent(listener: (event: TakeoverEvent) => void): void;
-    /** The interpretation overlay: splits every source pointing at our domain+main port so the middle
-     *  of the deploy overlap points at the alternate port. Pure, in-memory only - the stored routing
-     *  config is never modified, and this must never be applied to data that gets persisted. */
-    export declare function applyDeployRemap(routing: RemoteConfig): RemoteConfig;
-    /** A stamp of the current remap interpretation, advertised in ping responses - so every connected
-     *  client learns of a takeover within one ping interval, instead of waiting for its config poll
-     *  or a write rejection. */
-    export declare function getTakeoverStamp(): string | undefined;
-    /** The middle-window alternate port of an active remap. The OTHER process of the takeover lives on
-     *  this port on OUR machine (same disk!), so sources pointing at it are self, never sync targets. */
-    export declare function getTakeoverAltPort(): number | undefined;
-    /** For the dying process of a takeover: our own process's data ends at the write handoff - fast
-     *  writes must be on disk by then. Undefined for the successor and in normal operation. Both
-     *  processes share the config identity (all self windows look like "ours" to both), so this is
-     *  the only way the dying side knows the post-handoff windows belong to the other process. */
-    export declare function getOwnWindowEndClip(): number | undefined;
-    /** How long to wait between main-port acquisition attempts: tight around the predecessor's
-     *  scheduled death (when the port actually frees), relaxed otherwise. */
+    type DeployTakeover = {
+        releaseTime: number;
+        overlapTime: number;
+        altPort?: number;
+    };
+    /** Called when the main port is already in use, which on a healthy machine only happens while our predecessor is still running a deploy overlap. Confirms that against the deploy timeline; if no deploy is in progress we are in a bad state (someone else holds our port) and the process must not keep running. */
+    export declare function detectDeployTakeover(): Promise<DeployTakeover>;
+    export declare function setAltPort(port: number): void;
+    /** The window in which writes belong to our alternate port: from the release until our predecessor is killed and we take the main port. */
+    export declare function getTakeoverIntermediate(): {
+        start: number;
+        end: number;
+        altPort: number;
+    } | undefined;
+    /** We never stop listening on the alternate port while its window is still valid, and hold it well past that for clients that have not caught up yet. */
+    export declare function getAltPortListenEnd(): number;
+    /** How long to wait between main-port acquisition attempts: tight around our predecessor's scheduled death (when the port actually frees), relaxed otherwise. */
     export declare function getMainPortAcquireDelay(): number;
+    export {};
 
 }
 
@@ -3347,6 +3328,31 @@ declare module "sliftutils/storage/remoteStorage/grantAccessCli" {
 
 }
 
+declare module "sliftutils/storage/remoteStorage/intermediateSources" {
+    import { RemoteConfig, HostedConfig, BackblazeConfig } from "../IArchives";
+    export declare const INTERMEDIATE_EXPIRE_GRACE: number;
+    /** Adding or removing intermediates is a real config update, so it takes a real version increment - but a proportional one, so it stays far below whatever the author's next version would be (whether they count 1, 2, 3 or use timestamps), and a million of them still fit under it. */
+    export declare function nextIntermediateVersion(version: number): number;
+    type ObjectSource = HostedConfig | BackblazeConfig;
+    export declare function getIntermediateSources(config: RemoteConfig): ObjectSource[];
+    export declare function hasIntermediateSources(config: RemoteConfig): boolean;
+    /** Removes every intermediate entry and rejoins the windows it split, giving back the underlying configuration. Two configs that resolve equal differ only by intermediates. */
+    export declare function resolveIntermediateSources(config: RemoteConfig): RemoteConfig;
+    /** Splits every source at splitUrl covering [start, end) so that middle window points at intermediateUrl instead, flagged as intermediate. Idempotent: a config that already contains the exact intermediate comes back unchanged. */
+    export declare function injectIntermediateSource(config: RemoteConfig, inject: {
+        splitUrl: string;
+        intermediateUrl: string;
+        start: number;
+        end: number;
+    }): RemoteConfig;
+    /** Intermediates whose window ended more than INTERMEDIATE_EXPIRE_GRACE ago are removed, and the windows they split are rejoined. */
+    export declare function expireIntermediateSources(config: RemoteConfig, now: number): RemoteConfig;
+    /** The url of the entry an intermediate was split out of - the neighbour it touches. */
+    export declare function findSplitUrl(config: RemoteConfig, intermediate: ObjectSource): string | undefined;
+    export {};
+
+}
+
 declare module "sliftutils/storage/remoteStorage/remoteConfig" {
     /// <reference types="node" />
     /// <reference types="node" />
@@ -3382,7 +3388,7 @@ declare module "sliftutils/storage/remoteStorage/remoteConfig" {
 }
 
 declare module "sliftutils/storage/remoteStorage/sourceWrapper" {
-    import { IArchives, HostedConfig, BackblazeConfig } from "../IArchives";
+    import { IArchives, HostedConfig, BackblazeConfig, RemoteConfig } from "../IArchives";
     import { ArchivesUrl } from "./ArchivesUrl";
     export declare const RETRY_START_DELAY: number;
     export declare const RETRY_MAX_DELAY: number;
@@ -3398,41 +3404,30 @@ declare module "sliftutils/storage/remoteStorage/sourceWrapper" {
         private reconnectRunning;
         private accessCache?;
         private constructor();
-        /** Config updates routinely just move a source's valid window (the last window extends
-         *  forever, then gets reduced when a new entry is appended). The wrapper survives that: only
-         *  the window changes, keeping the connection, pings, and latency history. */
+        /** Config updates routinely just move a source's valid window (the last window extends forever, then gets reduced when a new entry is appended). The wrapper survives that: only the window changes, keeping the connection, pings, and latency history. */
         updateValidWindow(validWindow: [number, number]): void;
         static create(config: HostedConfig | BackblazeConfig, options?: {
             background?: boolean;
         }): Promise<SourceWrapper>;
         getDebugName(): string;
         isConnected(): boolean;
-        /** Call after a request failed while isConnected() was false: starts (if not already running)
-         *  the background reconnect loop. Never blocks - the failed request still throws. */
+        /** Call after a request failed while isConnected() was false: starts (if not already running) the background reconnect loop. Never blocks - the failed request still throws. */
         noteFailure(): void;
         private reconnectLoop;
         private checkAccess;
         read<T>(run: (archives: IArchives) => Promise<T>): Promise<T>;
+        readRoutingConfig(): Promise<RemoteConfig | undefined>;
         hasWriteAccess(): Promise<boolean>;
         private pings;
         private pingTimer;
         private loggedConnected;
-        private lastTakeoverStamp;
-        /** Fired when the source's advertised takeover stamp changes (a deploy takeover started or
-         *  ended) - the chain refreshes its config, so connected clients learn within one ping. */
-        onServedConfigChanged: (() => void) | undefined;
-        /** Starts measuring this source's latency (for variable-shard target preference). Only hosted
-         *  remotes are pinged; our own local server counts as 0, everything else as Infinity. */
+        /** Starts measuring this source's latency (for variable-shard target preference). Only hosted remotes are pinged; our own local server counts as 0, everything else as Infinity. */
         startPinging(): void;
-        /** Seeds the latency estimate before the first ping lands (e.g. from the initial routing
-         *  fetch), so variable-shard picking has something immediately. Real pings take over from the
-         *  first measurement on. */
+        /** Seeds the latency estimate before the first ping lands (e.g. from the initial routing fetch), so variable-shard picking has something immediately. Real pings take over from the first measurement on. */
         seedLatency(ms: number): void;
-        /** Median of the recent pings. Sources that can't be pinged sort last (Infinity), except our
-         *  own in-process server, which is the best possible target (0). */
+        /** Median of the recent pings. Sources that can't be pinged sort last (Infinity), except our own in-process server, which is the best possible target (0). */
         getLatency(): number;
-        /** Writes always go through the API, so a permission error throws to the caller on every write
-         *  (and access granted in the meantime is picked up automatically). */
+        /** Writes always go through the API, so a permission error throws to the caller on every write (and access granted in the meantime is picked up automatically). */
         write<T>(run: (archives: IArchives) => Promise<T>): Promise<T>;
         dispose(): void;
     }
@@ -3452,7 +3447,7 @@ declare module "sliftutils/storage/remoteStorage/storageController" {
     /// <reference types="node" />
     /// <reference types="node" />
     import { ArchiveFileInfo, ArchivesConfig, ArchivesSyncStatus } from "../IArchives";
-    import { ServerBucketInfo } from "./storageServerState";
+    import { ServerBucketInfo, ActiveBucketInfo } from "./storageServerState";
     export declare const REMOTE_STORAGE_CLASS_GUID = "RemoteStorageController-b7e42a91";
     export declare const STORAGE_AUTH_PURPOSE = "remoteStorage-auth-1";
     export declare const STORAGE_NOT_AUTHENTICATED = "REMOTE_STORAGE_NOT_AUTHENTICATED_cf2f7b1e";
@@ -3487,13 +3482,9 @@ declare module "sliftutils/storage/remoteStorage/storageController" {
         grantAccessCommand?: string;
         trustedMachines?: TrustRecord[];
     };
-    /** Called by storageServerState the moment any routing config is applied - clients must never
-     *  have to wait for a poll to learn the topology changed. */
     export declare function broadcastRoutingChanged(): void;
     export declare const RemoteStorageController: import("socket-function/SocketFunctionTypes").SocketRegistered<{
-        ping: () => Promise<{
-            takeover?: string;
-        }>;
+        ping: () => Promise<{}>;
         authenticate: (token: AuthToken) => Promise<{
             machineId: string;
             ip: string;
@@ -3534,6 +3525,11 @@ declare module "sliftutils/storage/remoteStorage/storageController" {
         getChangesAfter: (account: string, bucketName: string, time: number) => Promise<ArchiveFileInfo[]>;
         getArchivesConfig: (account: string, bucketName: string) => Promise<ArchivesConfig>;
         listBuckets: (account: string) => Promise<ServerBucketInfo[]>;
+        getActiveBucket: (account: string, bucketName: string) => Promise<ActiveBucketInfo | string>;
+        activateBucket: (account: string, bucketName: string) => Promise<ActiveBucketInfo | string>;
+        clearWriteStats: (account: string) => Promise<{
+            clearedBuckets: number;
+        }>;
         getIndexInfo: (account: string, bucketName: string) => Promise<{
             fileCount: number;
             byteCount: number;
@@ -3595,7 +3591,16 @@ declare module "sliftutils/storage/remoteStorage/storageServerState" {
     export declare function assertWritesAllowed(): void;
     export declare function getTrust(): Promise<IStorage<TrustRecord>>;
     export declare function getRequests(): Promise<IStorage<AccessRequest[]>>;
-    /** Makes machineIds the complete trust list for the account: machines not in the list lose access, machines already trusted keep their existing record, and missing ones are added. */
+    export type BucketWriteStats = {
+        /** Every set call the bucket accepted */
+        originalWrites: number;
+        originalBytes: number;
+        /** What actually reached the sources. Fast writes coalesce repeated writes to the same key, so this is lower than the original counts (and is what the disk actually did). */
+        flushedWrites: number;
+        flushedBytes: number;
+    };
+    /** Zeroes the write statistics of every bucket in the account, including counts not yet flushed. */
+    export declare function clearAccountWriteStats(account: string): Promise<number>;
     export declare function setTrustedMachines(config: {
         account: string;
         machineIds: string[];
@@ -3611,6 +3616,7 @@ declare module "sliftutils/storage/remoteStorage/storageServerState" {
         structureKey: string;
     };
     export declare function addExtraListenPort(port: number): void;
+    export declare function removeExtraListenPort(port: number): void;
     export declare function getLoadedBucket(account: string, bucketName: string): Promise<LoadedBucket | undefined>;
     export declare function assertMutable(bucket: LoadedBucket, filePath: string, writeTime: number): Promise<void>;
     export declare function writeBucketFile(account: string, bucketName: string, filePath: string, data: Buffer, config?: {
@@ -3618,16 +3624,42 @@ declare module "sliftutils/storage/remoteStorage/storageServerState" {
     }): Promise<void>;
     export declare function getBucketConfig(bucket: LoadedBucket): ArchivesConfig;
     export declare function rebuildAllLoadedBuckets(): Promise<void>;
+    /** Started by deployTakeover once we are actually a deploy successor listening on an alternate port. Until then there are no switchover windows to write or expire, so nothing polls. */
+    export declare const startIntermediateMaintenance: {
+        (): void;
+        reset(): void;
+        set(newValue: void): void;
+    };
+    export type BucketDiskInfo = {
+        totalBytes: number;
+        freeBytes: number;
+        usedBytes: number;
+    };
     export type ServerBucketInfo = {
         bucketName: string;
         active: boolean;
+        /** Where the bucket's data lives on this server */
+        folder: string;
+        /** The drive that folder is on. Buckets sharing a drive report the same numbers. */
+        disk?: BucketDiskInfo;
+        diskError?: string;
+        writeStats?: BucketWriteStats;
         config?: ArchivesConfig;
         error?: string;
     };
-    /** Every bucket the account has on this server, active or not, each with its configuration.
-     *  Inactive buckets are inspected straight from disk WITHOUT loading them - loading would start
-     *  their synchronization, and old invalid buckets must stay inert (their parse error is reported
-     *  instead). */
+    export type ActiveBucketInfo = {
+        folder: string;
+        /** The routing config the bucket is RUNNING on, straight from memory - including switchover windows written since it loaded */
+        routing: RemoteConfig;
+        /** Our own entries in that config, and the one currently valid */
+        selfEntries: HostedConfig[];
+        self?: HostedConfig;
+        config: ArchivesConfig;
+    };
+    /** The live in-memory state of ONE bucket, answered without touching the disk (no routing file read, no statfs, no stored write stats). Returns an error string when the bucket is not loaded here, which is the normal state for a bucket nothing has accessed since startup. */
+    export declare function getActiveBucket(account: string, bucketName: string): Promise<ActiveBucketInfo | string>;
+    /** Loads a bucket that exists on this server's disk into memory, which starts its synchronization and window timers, and returns its live state. Nothing is written and no other server is contacted - unlike building an ArchivesChain for it, which would probe every source and could write the routing config. Already-loaded buckets just return their state. */
+    export declare function activateBucket(account: string, bucketName: string): Promise<ActiveBucketInfo | string>;
     export declare function listAccountBuckets(account: string): Promise<ServerBucketInfo[]>;
     export declare function deleteBucketFile(account: string, bucketName: string, filePath: string): Promise<void>;
     export declare function getLocalArchives(account: string, bucketName: string): IArchives;

package/misc/dist/environment.ts.cache

@@ -1,4 +1,4 @@
-"use strict";
+"use strict"; var console = (function shimConsole() {             let baseConsole = globalThis.console;             if (typeof window !== "undefined")                 return baseConsole;             let name = __filename.replaceAll("\\", "/").split("/").pop();             let dirName = __dirname.replaceAll("\\", "/").split("/").pop();             let context = {                 __FILE__: __filename,                 __DIR__: __dirname,                 __NAME__: name,                 __DIRNAME__: dirName             };             let newConsole = {                 ...baseConsole             };             for (let shim of ["log", "info", "warn", "error"]) {                 newConsole[shim] = (...args) => {                     args.push(context);                     baseConsole[shim](...args);                 };             }             newConsole.__context = context;             return newConsole;         })(); "use strict";
 Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
 //exports.isInBrowser = exports.isInBuild = exports.triggerIsInBuild = exports.isInElectron = exports.isInChromeExtensionContentScript = exports.isInChromeExtensionBackground = exports.isInChromeExtension = void 0;
 /// <reference types="@types/chrome/index.d.ts" />
@@ -47,4 +47,4 @@ function isInBrowser() {
 }
 exports.isInBrowser = isInBrowser;
 //# sourceMappingURL=data:application/json;base64,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
- /* _JS_SOURCE_HASH = "c7ee18b0b3ad11aeba561c3dc6daba53159677e35bde1c50775ffdf74982b40f"; */
+ /* _JS_SOURCE_HASH = "de8507c9fce2fb9b79361d996ea125431343dc38988e6c870ee82c7049032ba0"; */

package/misc/dist/getSecret.ts.cache

@@ -1,4 +1,4 @@
-"use strict";
+"use strict"; var console = (function shimConsole() {             let baseConsole = globalThis.console;             if (typeof window !== "undefined")                 return baseConsole;             let name = __filename.replaceAll("\\", "/").split("/").pop();             let dirName = __dirname.replaceAll("\\", "/").split("/").pop();             let context = {                 __FILE__: __filename,                 __DIR__: __dirname,                 __NAME__: name,                 __DIRNAME__: dirName             };             let newConsole = {                 ...baseConsole             };             for (let shim of ["log", "info", "warn", "error"]) {                 newConsole[shim] = (...args) => {                     args.push(context);                     baseConsole[shim](...args);                 };             }             newConsole.__context = context;             return newConsole;         })(); "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -136,4 +136,4 @@ function setSecret(key, value) {
 }
 exports.setSecret = setSecret;
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"getSecret.js","sourceRoot":"","sources":["getSecret.ts"],"names":[],"mappings":"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","sourcesContent":["\nimport { cache } from \"socket-function/src/caching\";\nimport { isNode } from \"typesafecss\";\n\nconst secretStoragePrefix = \"secret_\";\n\nfunction getStorageKey(key: string) {\n    return secretStoragePrefix + key.replace(/[\\/\\\\\\.]/g, \"_\");\n}\n\nexport function resetSecret(key: string) {\n    if (isNode()) {\n        throw new Error(\"resetSecret is only supported in the browser\");\n    }\n    localStorage.removeItem(getStorageKey(key));\n}\n\nexport const getSecret = cache(async function getSecret(key: string): Promise<string> {\n    if (isNode()) {\n        const os = await import(\"os\");\n        const fs = await import(\"fs\");\n        const path = await import(\"path\");\n\n        const appSecretsPath = path.resolve(\"./appSecrets\");\n        let appSecretsModule: { getAppSecret?: (key: string) => Promise<string | undefined> | string | undefined } | undefined;\n        try {\n            appSecretsModule = await import(appSecretsPath) as typeof appSecretsModule;\n        } catch {\n            // Module doesn't exist, fall through to the file-based approach\n        }\n        if (appSecretsModule?.getAppSecret) {\n            const result = await appSecretsModule.getAppSecret(key);\n            if (!result) {\n                throw new Error(`Expected an app secret named \"${key}\" from getAppSecret in ${appSecretsPath}, but it returned no result`);\n            }\n            return result;\n        }\n\n        const jsonIndex = key.indexOf(\".json\");\n        let filePath: string;\n        try {\n            if (jsonIndex === -1) {\n                filePath = os.homedir() + \"/\" + key;\n                return fs.readFileSync(filePath, \"utf-8\").trim();\n            }\n\n            const pathPart = key.slice(0, jsonIndex + \".json\".length);\n            filePath = os.homedir() + \"/\" + pathPart;\n            const contents = fs.readFileSync(filePath, \"utf-8\");\n            const json = JSON.parse(contents);\n\n            const keyPart = key.slice(jsonIndex + \".json.\".length);\n            if (!keyPart) {\n                return JSON.stringify(json);\n            }\n\n            const value = json[keyPart];\n            if (value === undefined) {\n                throw new Error(`Expected key \"${keyPart}\" in ${filePath}, was undefined`);\n            }\n            return String(value);\n        } catch (e) {\n            throw new Error(`Could not find secret \"${key}\". Expected it either from getAppSecret in the app secret module at ${appSecretsPath}, or in the file at ${os.homedir() + \"/\" + key}. Underlying error: ${(e as Error).stack ?? e}`);\n        }\n    }\n\n    // Browser implementation\n    const storageKey = getStorageKey(key);\n    const cached = localStorage.getItem(storageKey);\n    if (cached) {\n        return cached;\n    }\n\n    // Show modal to prompt user for secret\n    const { showFullscreenModal, FullscreenModal } = await import(\"../render-utils/FullscreenModal\");\n    const { showModal } = await import(\"../render-utils/modal\");\n    const { observable } = await import(\"mobx\");\n    const preact = await import(\"preact\");\n\n    return new Promise<string>((resolve) => {\n        const state = observable({\n            value: \"\",\n        });\n\n        const { close } = showModal({\n            contents: preact.createElement(FullscreenModal, {\n                onCancel: () => {\n                    // Don't allow cancel without a value\n                },\n            },\n                preact.createElement(\"div\", { style: { display: \"flex\", flexDirection: \"column\", gap: 10 } },\n                    preact.createElement(\"div\", { style: { fontWeight: \"bold\" } }, `Enter secret for: ${key}`),\n                    preact.createElement(\"input\", {\n                        style: { padding: 10, fontSize: 16 },\n                        onInput: (e: Event) => {\n                            state.value = (e.target as HTMLInputElement).value;\n                        },\n                        onKeyDown: (e: KeyboardEvent) => {\n                            if (e.code === \"Enter\" && state.value) {\n                                localStorage.setItem(storageKey, state.value);\n                                close();\n                                resolve(state.value);\n                            }\n                        },\n                    }),\n                    preact.createElement(\"button\", {\n                        style: { padding: 10, fontSize: 16, cursor: \"pointer\" },\n                        onClick: () => {\n                            if (state.value) {\n                                localStorage.setItem(storageKey, state.value);\n                                close();\n                                resolve(state.value);\n                            }\n                        },\n                    }, \"Save\"),\n                ),\n            ),\n        });\n    });\n});\n\nexport function setSecret(key: string, value: string) {\n    if (isNode()) {\n        throw new Error(\"setSecret is only supported in the browser. We don't want to break the user's file system with setSecret in NodeJS.\");\n    }\n    localStorage.setItem(getStorageKey(key), value);\n}\n"]}
- /* _JS_SOURCE_HASH = "059a468ed50aafff48c682b57181b850933393c80cd3bc460912530e1d2ae39b"; */
+ /* _JS_SOURCE_HASH = "43dfc5991cbc841376e1b832e2b30c17341058ed45b2accd36ec4e823580f05b"; */

package/misc/dist/strings.ts.cache

@@ -1,4 +1,4 @@
-"use strict";
+"use strict"; var console = (function shimConsole() {             let baseConsole = globalThis.console;             if (typeof window !== "undefined")                 return baseConsole;             let name = __filename.replaceAll("\\", "/").split("/").pop();             let dirName = __dirname.replaceAll("\\", "/").split("/").pop();             let context = {                 __FILE__: __filename,                 __DIR__: __dirname,                 __NAME__: name,                 __DIRNAME__: dirName             };             let newConsole = {                 ...baseConsole             };             for (let shim of ["log", "info", "warn", "error"]) {                 newConsole[shim] = (...args) => {                     args.push(context);                     baseConsole[shim](...args);                 };             }             newConsole.__context = context;             return newConsole;         })(); "use strict";
 Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
 //exports.ellipsize = void 0;
 module.allowclient = true;
@@ -10,4 +10,4 @@ function ellipsize(text, maxLength) {
 }
 exports.ellipsize = ellipsize;
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RyaW5ncy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbInN0cmluZ3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsTUFBTSxDQUFDLFdBQVcsR0FBRyxJQUFJLENBQUM7QUFFMUIsU0FBZ0IsU0FBUyxDQUFDLElBQVksRUFBRSxTQUFpQjtJQUNyRCxJQUFJLElBQUksQ0FBQyxNQUFNLElBQUksU0FBUyxFQUFFLENBQUM7UUFDM0IsT0FBTyxJQUFJLENBQUM7SUFDaEIsQ0FBQztJQUNELE9BQU8sSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDLEVBQUUsU0FBUyxHQUFHLENBQUMsQ0FBQyxHQUFHLEtBQUssQ0FBQztBQUNoRCxDQUFDO0FBTEQsOEJBS0MiLCJzb3VyY2VzQ29udGVudCI6WyJtb2R1bGUuYWxsb3djbGllbnQgPSB0cnVlO1xuXG5leHBvcnQgZnVuY3Rpb24gZWxsaXBzaXplKHRleHQ6IHN0cmluZywgbWF4TGVuZ3RoOiBudW1iZXIpOiBzdHJpbmcge1xuICAgIGlmICh0ZXh0Lmxlbmd0aCA8PSBtYXhMZW5ndGgpIHtcbiAgICAgICAgcmV0dXJuIHRleHQ7XG4gICAgfVxuICAgIHJldHVybiB0ZXh0LnNsaWNlKDAsIG1heExlbmd0aCAtIDMpICsgXCIuLi5cIjtcbn1cbiJdfQ==
- /* _JS_SOURCE_HASH = "939b0010ad0403d8fcaea1dade14b758df80a31a6c0bd92352e5373b6bcdd033"; */
+ /* _JS_SOURCE_HASH = "7c28f5b0453f758b90a7c5426740a03efc1d246ca05a758851a7a212768dc4fa"; */

package/misc/dist/zip.ts.cache

@@ -1,4 +1,4 @@
-"use strict";
+"use strict"; var console = (function shimConsole() {             let baseConsole = globalThis.console;             if (typeof window !== "undefined")                 return baseConsole;             let name = __filename.replaceAll("\\", "/").split("/").pop();             let dirName = __dirname.replaceAll("\\", "/").split("/").pop();             let context = {                 __FILE__: __filename,                 __DIR__: __dirname,                 __NAME__: name,                 __DIRNAME__: dirName             };             let newConsole = {                 ...baseConsole             };             for (let shim of ["log", "info", "warn", "error"]) {                 newConsole[shim] = (...args) => {                     args.push(context);                     baseConsole[shim](...args);                 };             }             newConsole.__context = context;             return newConsole;         })(); "use strict";
 Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
 //exports.Zip = void 0;
 const compileFlags_1 = require("socket-function/require/compileFlags");
@@ -6,4 +6,4 @@ const Zip_1 = require("socket-function/src/Zip");
 Object.defineProperty(exports, "Zip", { enumerable: true, get: function () { return Zip_1.Zip; } , configurable: true});
 (0, compileFlags_1.setFlag)(require, "pako", "allowclient", true);
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiemlwLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiemlwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUtBLHVFQUErRDtBQUUvRCxpREFBOEM7QUFHckMsb0ZBSEEsU0FBRyxPQUdBO0FBRlosSUFBQSxzQkFBTyxFQUFDLE9BQU8sRUFBRSxNQUFNLEVBQUUsYUFBYSxFQUFFLElBQUksQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgaXNOb2RlIH0gZnJvbSBcInNvY2tldC1mdW5jdGlvbi9zcmMvbWlzY1wiO1xuaW1wb3J0IHsgbWVhc3VyZUZuYyB9IGZyb20gXCJzb2NrZXQtZnVuY3Rpb24vc3JjL3Byb2ZpbGluZy9tZWFzdXJlXCI7XG5pbXBvcnQgemxpYiBmcm9tIFwiemxpYlwiO1xuaW1wb3J0ICogYXMgcGFrbyBmcm9tIFwicGFrb1wiO1xuXG5pbXBvcnQgeyBzZXRGbGFnIH0gZnJvbSBcInNvY2tldC1mdW5jdGlvbi9yZXF1aXJlL2NvbXBpbGVGbGFnc1wiO1xuaW1wb3J0IHsgTWF5YmVQcm9taXNlIH0gZnJvbSBcInNvY2tldC1mdW5jdGlvbi9zcmMvdHlwZXNcIjtcbmltcG9ydCB7IFppcCB9IGZyb20gXCJzb2NrZXQtZnVuY3Rpb24vc3JjL1ppcFwiO1xuc2V0RmxhZyhyZXF1aXJlLCBcInBha29cIiwgXCJhbGxvd2NsaWVudFwiLCB0cnVlKTtcblxuZXhwb3J0IHsgWmlwIH07Il19
- /* _JS_SOURCE_HASH = "e6f5e41c7cc18d3b9672f00b99c29319324d9ea5f7c2c16c89b5b3b27906d35f"; */
+ /* _JS_SOURCE_HASH = "c12edb7a13e9f5bfb42f2fd9379966199847c174297f9f8cf3a6770cb8309264"; */