sliftutils 1.7.32 → 1.7.33

package/storage/remoteFileServer.ts

@@ -19,13 +19,9 @@ process.on("unhandledRejection", reason => {
     console.error(`[writeServer] unhandledRejection (continuing):`, (reason as Error)?.stack ?? reason);
 });
 
-// Remote file server for sliftutils getRemoteFileStorage / BulkDatabase2. Serves one folder on disk over
-// self-signed HTTPS, authenticated with an auto-generated 6-word password (sent as
-// `Authorization: Bearer <password>`). Run it with `yarn filehoster <folder>` (or the `filehoster` bin).
-//
-// SECURITY: the cert is self-signed, so a browser must accept it once (open the printed https URL and
-// click through), and the Node client connects with cert verification disabled. The password is what
-// authorizes access; keep it secret.
+// Remote file server for sliftutils getRemoteFileStorage / BulkDatabase2. Serves one folder on disk over self-signed HTTPS, authenticated with an auto-generated 6-word password (sent as `Authorization: Bearer <password>`). Run it with `yarn filehoster <folder>` (or the `filehoster` bin).
+// 
+// SECURITY: the cert is self-signed, so a browser must accept it once (open the printed https URL and click through), and the Node client connects with cert verification disabled. The password is what authorizes access; keep it secret.
 
 // Common, memorable words (frequency-ordered subset) for passphrase generation.
 const WORDS: string[] = [
@@ -207,16 +203,12 @@ export function generatePassword(wordCount: number): string {
     return words.join(" ");
 }
 
-// The password is always a list of words, so we compare case-insensitively and ignore any non-letter
-// characters. That makes it forgiving of voice dictation and mobile autocorrect (spacing, capitals,
-// stray punctuation) without meaningfully weakening a 6-word passphrase.
+// The password is always a list of words, so we compare case-insensitively and ignore any non-letter characters. That makes it forgiving of voice dictation and mobile autocorrect (spacing, capitals, stray punctuation) without meaningfully weakening a 6-word passphrase.
 function normalizePassword(p: string): string {
     return String(p || "").toLowerCase().replace(/[^a-z]/g, "");
 }
 
-// The password is generated once and saved (next to the cert, outside the served folder), then reused
-// across restarts — so connected clients keep working after the server bounces, instead of getting a
-// new password every time. Override with the PASSWORD env var.
+// The password is generated once and saved (next to the cert, outside the served folder), then reused across restarts — so connected clients keep working after the server bounces, instead of getting a new password every time. Override with the PASSWORD env var.
 function getOrCreatePassword(): string {
     const dir = path.join(os.homedir(), ".sliftutils-remote");
     fs.mkdirSync(dir, { recursive: true });
@@ -230,8 +222,7 @@ function getOrCreatePassword(): string {
     return pw;
 }
 
-// Generate (once) and cache a self-signed key + cert via openssl, outside the served folder so its
-// private key is never reachable through the API.
+// Generate (once) and cache a self-signed key + cert via openssl, outside the served folder so its private key is never reachable through the API.
 function getCert(): { key: Buffer; cert: Buffer } {
     const dir = path.join(os.homedir(), ".sliftutils-remote");
     fs.mkdirSync(dir, { recursive: true });
@@ -284,9 +275,7 @@ function formatBytes(n: number): string {
     return (n / 1024 / 1024 / 1024).toFixed(2) + "GB";
 }
 
-// Parse a single-range HTTP Range header ("bytes=start-end", "bytes=start-", "bytes=-suffix") into an
-// INCLUSIVE [start, end]. Returns "unsatisfiable" for a range past the file, or undefined for no/garbled
-// range (caller then serves the whole file). Only single ranges are supported (what media players use).
+// Parse a single-range HTTP Range header ("bytes=start-end", "bytes=start-", "bytes=-suffix") into an INCLUSIVE [start, end]. Returns "unsatisfiable" for a range past the file, or undefined for no/garbled range (caller then serves the whole file). Only single ranges are supported (what media players use).
 function parseRange(header: string, size: number): { start: number; end: number } | "unsatisfiable" | undefined {
     const m = /^bytes=(\d*)-(\d*)$/.exec(header.trim());
     if (!m) return undefined;
@@ -318,9 +307,7 @@ function mediaContentType(filePath: string): string {
     return MEDIA_TYPES[ext] || "application/octet-stream";
 }
 
-// Public (no-auth) landing page. The browser can't trust a self-signed cert from a background fetch, so
-// the user opens this URL once, accepts the browser's security warning, and the cert becomes trusted for
-// the origin — then the app's fetches work. This page is what they see after accepting.
+// Public (no-auth) landing page. The browser can't trust a self-signed cert from a background fetch, so the user opens this URL once, accepts the browser's security warning, and the cert becomes trusted for the origin — then the app's fetches work. This page is what they see after accepting.
 const CERT_LANDING_HTML = `<!doctype html><html><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>sliftutils file server</title></head><body style="font-family:system-ui,sans-serif;max-width:34em;margin:3em auto;padding:0 1em;line-height:1.5;color:#222"><h2>&#10003; Certificate accepted</h2><p>This is your <b>sliftutils file server</b>. Your browser now trusts its self-signed certificate for this address.</p><p>Return to the app and click <b>Retry</b> (or <b>Connect</b>) to finish connecting with your password.</p><p style="color:#888;font-size:.9em">You can close this tab.</p></body></html>`;
 
 export type RemoteFileServerOptions = {
@@ -328,8 +315,7 @@ export type RemoteFileServerOptions = {
     port?: number;
     host?: string;
     password?: string;
-    // When true, log batched per-(client, file) access totals every 5s. The CLI turns this on; the
-    // library (tests) leaves it off.
+    // When true, log batched per-(client, file) access totals every 5s. The CLI turns this on; the library (tests) leaves it off.
     logAccess?: boolean;
 };
 export type RemoteFileServerHandle = { port: number; password: string; url: string; close: () => Promise<void> };
@@ -343,8 +329,7 @@ export function startRemoteFileServer(options: RemoteFileServerOptions): Promise
     const normPassword = normalizePassword(password);
     const { key, cert } = getCert();
 
-    // Batched access log: aggregate per (ip, op, file) so hammering one file logs once per 5s with the
-    // total request count and bytes, instead of a line per request.
+    // Batched access log: aggregate per (ip, op, file) so hammering one file logs once per 5s with the total request count and bytes, instead of a line per request.
     type Acc = { ip: string; op: string; path: string; count: number; bytes: number };
     const accessLog = new Map<string, Acc>();
     let flushTimer: ReturnType<typeof setInterval> | undefined;
@@ -361,8 +346,7 @@ export function startRemoteFileServer(options: RemoteFileServerOptions): Promise
             if (!accessLog.size) return;
             const rows = [...accessLog.values()].sort((a, b) => b.bytes - a.bytes);
             accessLog.clear();
-            // Fixed-width columns first so lines align, then the variable-length path last. count is the
-            // number of requests folded into this row (R = requests, not a multiplier).
+            // Fixed-width columns first so lines align, then the variable-length path last. count is the number of requests folded into this row (R = requests, not a multiplier).
             const time = new Date().toTimeString().slice(0, 8);
             for (const e of rows) {
                 const size = formatBytes(e.bytes).padStart(9);
@@ -437,8 +421,7 @@ export function startRemoteFileServer(options: RemoteFileServerOptions): Promise
                 fs.createReadStream(full, { start, end: end - 1 }).on("error", () => res.end()).pipe(res);
                 return;
             }
-            // Range-capable media endpoint for <video>/<img>/fetch: honors the Range header (206 +
-            // Content-Range + Accept-Ranges) so seeking works. Auth came from the ?token= query above.
+            // Range-capable media endpoint for <video>/<img>/fetch: honors the Range header (206 + Content-Range + Accept-Ranges) so seeking works. Auth came from the ?token= query above.
             if ((req.method === "GET" || req.method === "HEAD") && op === "/media") {
                 let st: fs.Stats;
                 try { st = fs.statSync(full); } catch { return sendJson(404, { error: "not found" }); }
@@ -483,9 +466,7 @@ export function startRemoteFileServer(options: RemoteFileServerOptions): Promise
         }
     });
 
-    // WebSocket transport: same operations as the HTTP handler, but binary-framed and multiplexed over one
-    // socket so large concurrent reads don't pay per-request HTTP overhead. Frame: [u32 headerLen LE][header
-    // JSON][body bytes]. Request header {id, op, path, start?, end?, password?}; response {id, status, error?}.
+    // WebSocket transport: same operations as the HTTP handler, but binary-framed and multiplexed over one socket so large concurrent reads don't pay per-request HTTP overhead. Frame: [u32 headerLen LE][header JSON][body bytes]. Request header {id, op, path, start?, end?, password?}; response {id, status, error?}.
     const EMPTY = Buffer.alloc(0);
     const wss = new WebSocketServer({ server });
     wss.on("connection", (ws: WebSocket, req: IncomingMessage) => {
@@ -579,13 +560,9 @@ export function startRemoteFileServer(options: RemoteFileServerOptions): Promise
 }
 
 // ── server-side compaction (--autocompact) ──
-// Remote clients (e.g. a TV) skip compaction by default — it's expensive to read/rewrite whole files over
-// the network. So the host can do it locally instead: load each bulk database's index and run one merge
-// pass, on startup and every 3 hours. Far more efficient (local disk, no network), and the data still gets
-// compacted eventually.
+// Remote clients (e.g. a TV) skip compaction by default — it's expensive to read/rewrite whole files over the network. So the host can do it locally instead: load each bulk database's index and run one merge pass, on startup and every 3 hours. Far more efficient (local disk, no network), and the data still gets compacted eventually.
 const AUTOCOMPACT_INTERVAL_MS = 3 * 60 * 60 * 1000;
-// One reused compactor instance per collection (keyed by baseDir\0name), so we don't leak the per-instance
-// timers/caches by recreating instances each loop.
+// One reused compactor instance per collection (keyed by baseDir\0name), so we don't leak the per-instance timers/caches by recreating instances each loop.
 const compactors = new Map<string, BulkDatabaseBase<{ key: string }>>();
 function getCompactor(baseDir: string, name: string): BulkDatabaseBase<{ key: string }> {
     const key = baseDir + "\0" + name;
@@ -603,11 +580,9 @@ function getCompactor(baseDir: string, name: string): BulkDatabaseBase<{ key: st
     return db;
 }
 
-// One full pass: rescan the disk for collections (new ones may have appeared) and run a merge on each,
-// strictly one after another (never in parallel).
+// One full pass: rescan the disk for collections (new ones may have appeared) and run a merge on each, strictly one after another (never in parallel).
 export async function autocompactBulkDatabases(root: string): Promise<void> {
-    // Collections live under <baseDir>/bulkDatabases2/<name>/. The app may nest its data under a "data"
-    // subfolder (see getFileStorageNested2's heuristic), so look in both <root> and <root>/data.
+    // Collections live under <baseDir>/bulkDatabases2/<name>/. The app may nest its data under a "data" subfolder (see getFileStorageNested2's heuristic), so look in both <root> and <root>/data.
     const collections: { baseDir: string; name: string }[] = [];
     for (const baseDir of [root, path.join(root, "data")]) {
         try {
@@ -641,8 +616,7 @@ export async function autocompactBulkDatabases(root: string): Promise<void> {
     console.log(`  [autocompact] done all ${total} collection(s) (${Date.now() - passStart}ms)`);
 }
 
-// CLI entry (invoked by bin/filehoster.js or `yarn filehoster <folder>`). Starts the server, logs the
-// password + local/public URLs + batched access, and keeps the UPnP port mapping alive.
+// CLI entry (invoked by bin/filehoster.js or `yarn filehoster <folder>`). Starts the server, logs the password + local/public URLs + batched access, and keeps the UPnP port mapping alive.
 export async function runFileHoster(): Promise<void> {
     const args = process.argv.slice(2);
     const root = args.find(a => !a.startsWith("--") && !a.endsWith(".ts") && !a.endsWith(".js"));
@@ -657,8 +631,7 @@ export async function runFileHoster(): Promise<void> {
     let externalIP: string | undefined;
     try { externalIP = (await getExternalIP()).trim(); } catch { /* offline / unreachable */ }
 
-    // What the user types into the app: just the host, plus ":port" only if it's not the default. No
-    // scheme — the app always uses https.
+    // What the user types into the app: just the host, plus ":port" only if it's not the default. No scheme — the app always uses https.
     const host = externalIP || "localhost";
     const appAddress = host + (info.port === 8787 ? "" : ":" + info.port);
     const certUrl = "https://" + host + ":" + info.port;
@@ -679,8 +652,7 @@ export async function runFileHoster(): Promise<void> {
         // No UI to protect on a host, so don't space merges out — compact promptly each pass.
         bulkDatabase2Timing.mergeSpacingMs = 0;
         console.log("  [autocompact] compacting bulk databases on startup, then every 3h (serial)\n");
-        // Fire-and-forget: runs the first pass now and re-runs every 3h. Not awaited, so it doesn't block
-        // startup; each pass rescans the disk for new collections and merges them one at a time.
+        // Fire-and-forget: runs the first pass now and re-runs every 3h. Not awaited, so it doesn't block startup; each pass rescans the disk for new collections and merges them one at a time.
         void runInfinitePollCallAtStart(AUTOCOMPACT_INTERVAL_MS, () => autocompactBulkDatabases(root))
             .catch(e => console.error("  [autocompact] poll error:", (e as Error).stack));
     }

package/storage/remoteFileStorage.ts

@@ -1,13 +1,9 @@
 import { isNode } from "typesafecss";
 import type { DirectoryWrapper, FileWrapper } from "./FileFolderAPI";
 
-// A remote server (remoteFileServer.js) exposed as a DirectoryWrapper — the SAME interface as the
-// Node.js and File-System-Access handles. So getDirectoryHandle can return one of these and everything
-// downstream (wrapHandle, navigation, BulkDatabase2) works unchanged; nothing else knows it's remote.
-//
-// Files here are immutable (written once) or append-only, so the range cache (raw compressed bytes, in
-// ~1MB aligned chunks) is always valid — over the network latency dominates, so reading 1MB costs about
-// the same as 64KB and far fewer round trips wins.
+// A remote server (remoteFileServer.js) exposed as a DirectoryWrapper — the SAME interface as the Node.js and File-System-Access handles. So getDirectoryHandle can return one of these and everything downstream (wrapHandle, navigation, BulkDatabase2) works unchanged; nothing else knows it's remote.
+// 
+// Files here are immutable (written once) or append-only, so the range cache (raw compressed bytes, in ~1MB aligned chunks) is always valid — over the network latency dominates, so reading 1MB costs about the same as 64KB and far fewer round trips wins.
 
 const EMPTY = Buffer.alloc(0);
 const DEFAULT_CHUNK_BYTES = 1024 * 1024;
@@ -31,15 +27,11 @@ const sleep = (ms: number) => new Promise<void>(r => setTimeout(r, ms));
 
 type Stat = { size: number; lastModified: number; dir: boolean };
 
-// A stat is cached this long, so the burst of size lookups during a single read pass is one request per
-// file, not one per block. Short enough that an append by another writer shows up promptly; our own
-// writes invalidate it immediately.
+// A stat is cached this long, so the burst of size lookups during a single read pass is one request per file, not one per block. Short enough that an append by another writer shows up promptly; our own writes invalidate it immediately.
 const INFO_TTL_MS = 2000;
-// We keep at most this many bytes of read/write requests in flight at once (the rest queue), so a big
-// read doesn't fire hundreds of MB of requests at the server simultaneously.
+// We keep at most this many bytes of read/write requests in flight at once (the rest queue), so a big read doesn't fire hundreds of MB of requests at the server simultaneously.
 const MAX_INFLIGHT_BYTES = 64 * 1024 * 1024;
-// A single read request fetches at most this much; large reads are split into this many concurrent
-// requests (bounded by MAX_INFLIGHT_BYTES).
+// A single read request fetches at most this much; large reads are split into this many concurrent requests (bounded by MAX_INFLIGHT_BYTES).
 const DEFAULT_MAX_FETCH_BYTES = 4 * 1024 * 1024;
 const STATS_LOG_INTERVAL_MS = 10 * 1000;
 const RECV_WINDOW_MS = 60 * 1000;
@@ -86,9 +78,7 @@ function decodeFrame(buf: Buffer): { header: any; body: Buffer } {
 
 type QueuedRequest = { id: number; frame: Buffer; bytes: number; resolve: (r: { status: number; body: Buffer }) => void; reject: (e: Error) => void };
 
-// One WebSocket to a remote server, multiplexing all ops over it. Requests are queued and only sent
-// while < MAX_INFLIGHT_BYTES are outstanding; every 10s (when there's traffic) it logs the queue depth
-// and throughput.
+// One WebSocket to a remote server, multiplexing all ops over it. Requests are queued and only sent while < MAX_INFLIGHT_BYTES are outstanding; every 10s (when there's traffic) it logs the queue depth and throughput.
 class Connection {
     private cache: RangeCache;
     private infoCache = new Map<string, { stat: Stat | undefined; at: number }>();
@@ -197,8 +187,7 @@ class Connection {
         }
     }
 
-    // Sends one request over the WebSocket (queued + throttled). `bytes` is the expected payload size,
-    // used for the in-flight cap.
+    // Sends one request over the WebSocket (queued + throttled). `bytes` is the expected payload size, used for the in-flight cap.
     private async request(op: string, params: Record<string, unknown>, body: Buffer | undefined, bytes: number): Promise<{ status: number; body: Buffer }> {
         if (this.opts.latencyMs) await sleep(this.opts.latencyMs);
         await this.ensureConnected();
@@ -254,9 +243,7 @@ class Connection {
     }
 }
 
-// Caches the longest-known prefix of each aligned chunk per path. Valid because files are immutable or
-// append-only (the bytes at an offset never change). It only does range reads — it doesn't care what
-// the files are.
+// Caches the longest-known prefix of each aligned chunk per path. Valid because files are immutable or append-only (the bytes at an offset never change). It only does range reads — it doesn't care what the files are.
 class RangeCache {
     private chunks = new Map<string, Buffer>(); // path + "
" + chunkIndex, insertion-ordered (LRU)
     private bytes = 0;
@@ -337,8 +324,7 @@ const joinPath = (base: string, key: string) => (base ? base + "/" + key : key);
 const baseName = (p: string) => p.split("/").filter(Boolean).pop() || "";
 
 class RemoteFileWrapper implements FileWrapper {
-    // `stat` is supplied when the parent already statted us (avoids a second /info). `createIntent` means
-    // this was opened with create:true, so a missing file reads as empty (it'll be created on write).
+    // `stat` is supplied when the parent already statted us (avoids a second /info). `createIntent` means this was opened with create:true, so a missing file reads as empty (it'll be created on write).
     constructor(private conn: Connection, private filePath: string, private stat?: Stat, private createIntent = false) { }
     // Mirror the native FileSystemFileHandle shape so code written against it works unchanged.
     readonly kind = "file" as const;
@@ -359,8 +345,7 @@ class RemoteFileWrapper implements FileWrapper {
         };
     }
     async getURL() {
-        // HTTPS URL into the server's range-capable /media endpoint. The token rides in the query because a
-        // <video>/<img> element can't send an Authorization header.
+        // HTTPS URL into the server's range-capable /media endpoint. The token rides in the query because a <video>/<img> element can't send an Authorization header.
         return `${this.conn.url}/media?path=${encodeURIComponent(this.filePath)}&token=${encodeURIComponent(this.conn.password)}`;
     }
     async createWritable(config?: { keepExistingData?: boolean }) {
@@ -379,8 +364,7 @@ class RemoteFileWrapper implements FileWrapper {
 
 class RemoteDirectoryWrapper implements DirectoryWrapper {
     constructor(private conn: Connection, private dirPath: string) { }
-    // Mirror the native FileSystemDirectoryHandle shape (name/kind/entries) so code written against the
-    // native API — e.g. recursive walks using `handle.entries()` — works the same over the network.
+    // Mirror the native FileSystemDirectoryHandle shape (name/kind/entries) so code written against the native API — e.g. recursive walks using `handle.entries()` — works the same over the network.
     readonly kind = "directory" as const;
     readonly isRemote = true;
     get name() { return baseName(this.dirPath); }
@@ -403,8 +387,7 @@ class RemoteDirectoryWrapper implements DirectoryWrapper {
         }
         return new RemoteDirectoryWrapper(this.conn, p);       // dirs are created lazily on first write
     }
-    // Each entry is itself a real handle (a sub-wrapper), so a recursive walk over .entries() keeps
-    // working at every level — exactly like the native API.
+    // Each entry is itself a real handle (a sub-wrapper), so a recursive walk over .entries() keeps working at every level — exactly like the native API.
     async *[Symbol.asyncIterator](): AsyncIterableIterator<[string, RemoteFileWrapper | RemoteDirectoryWrapper]> {
         const entries = await this.conn.list(this.dirPath);
         for (const e of entries) {
@@ -428,9 +411,7 @@ export function getRemoteDirectoryHandle(url: string, password: string, options:
 
 export type RemoteConnectResult = { status: "ok" } | { status: "unauthorized" } | { status: "unreachable"; error: string };
 
-// Verifies a server is reachable and the password works — by opening the WebSocket, authenticating, and
-// listing the root. Distinguishes "connected" / "wrong password" / "couldn't reach it" (the last usually
-// meaning the self-signed cert isn't trusted yet in the browser, since the socket just fails to open).
+// Verifies a server is reachable and the password works — by opening the WebSocket, authenticating, and listing the root. Distinguishes "connected" / "wrong password" / "couldn't reach it" (the last usually meaning the self-signed cert isn't trusted yet in the browser, since the socket just fails to open).
 export async function testRemoteConnection(url: string, password: string, options: RemoteOptions = {}): Promise<RemoteConnectResult> {
     const conn = new Connection(url, password, options);
     try {

package/storage/remoteStorage/ArchivesRemote.d.ts

@@ -3,7 +3,6 @@
 import { IArchives, ArchiveFileInfo, ArchivesConfig, ArchivesSyncStatus } from "../IArchives";
 export type ArchivesRemoteConfig = {
     url: string;
-    accountName?: string;
     waitForAccess?: boolean;
 };
 export declare function parseStorageUrl(url: string): {
@@ -29,9 +28,7 @@ export declare class ArchivesRemote implements IArchives {
     private lastDeniedLog;
     getDebugName(): string;
     isConnected(): boolean;
-    ping(): Promise<{
-        takeover?: string;
-    }>;
+    ping(): Promise<{}>;
     private authenticate;
     private callAuthed;
     waitingForAccess(): Promise<{

package/storage/remoteStorage/ArchivesRemote.ts

@@ -11,10 +11,7 @@ import {
     STORAGE_NOT_AUTHENTICATED, STORAGE_ACCESS_DENIED,
 } from "./storageController";
 
-// A bucket on our remote storage server (storageServer.ts), used like ArchivesBackblaze. Works in
-// Node.js and the browser. Authenticates with this machine's certs.ts identity; if the account
-// hasn't trusted this machine yet it requests access, and by default waits, logging instructions
-// every minute (calls block until access is granted).
+// A bucket on our remote storage server (storageServer.ts), used like ArchivesBackblaze. Works in Node.js and the browser. Authenticates with this machine's certs.ts identity; if the account hasn't trusted this machine yet it requests access, and by default waits, logging instructions every minute (calls block until access is granted).
 
 const ACCESS_RETRY_DELAY = 1000 * 30;
 const LARGE_FILE_PART_SIZE = 8 * 1024 * 1024;
@@ -23,10 +20,7 @@ export type ArchivesRemoteConfig = {
     // The bucket's routing URL, which addresses the server, account, and bucket in one:
     //  https://storage.example.com:4444/file/<account>/<bucketName>/storage/storagerouting.json
     url: string;
-    // Access is checked against this account (defaults to the account in the url)
-    accountName?: 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).
+    // 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;
 };
 
@@ -40,8 +34,7 @@ export function parseStorageUrl(url: string): { address: string; port: number }
 
 // Authenticates a connection to a storage server with this machine's certs.ts identity
 export async function authenticateStorage(config: { address: string; port: number; nodeId: string }): Promise<{ machineId: string; ip: string }> {
-    // hostServer nodeIds are machine-specific, so connections by domain must target "any server
-    // at this address" (which is how browsers always connect)
+    // hostServer nodeIds are machine-specific, so connections by domain must target "any server at this address" (which is how browsers always connect)
     SocketFunction.ENABLE_CLIENT_MODE = true;
     let rootDomain = config.address.split(".").slice(-2).join(".");
     await loadIdentityCA(rootDomain);
@@ -57,13 +50,12 @@ export async function authenticateStorage(config: { address: string; port: numbe
 
 export class ArchivesRemote implements IArchives {
     constructor(private config: ArchivesRemoteConfig) {
-        // hostServer nodeIds are machine-specific, so connections by domain must target "any
-        // server at this address" (which is how browsers always connect)
+        // hostServer nodeIds are machine-specific, so connections by domain must target "any server at this address" (which is how browsers always connect)
         SocketFunction.ENABLE_CLIENT_MODE = true;
     }
 
     private parsed = parseHostedUrl(this.config.url);
-    private account = this.config.accountName || this.parsed.account;
+    private account = this.parsed.account;
     private bucketName = this.parsed.bucketName;
     private nodeId = SocketFunction.connect({ address: this.parsed.address, port: this.parsed.port });
     private controller = RemoteStorageController.nodes[this.nodeId];
@@ -77,7 +69,7 @@ export class ArchivesRemote implements IArchives {
         return SocketFunction.isNodeConnected(this.nodeId);
     }
 
-    public async ping(): Promise<{ takeover?: string }> {
+    public async ping(): Promise<{}> {
         return await this.controller.ping();
     }
 
@@ -85,8 +77,7 @@ export class ArchivesRemote implements IArchives {
         await authenticateStorage({ address: this.parsed.address, port: this.parsed.port, nodeId: this.nodeId });
     }
 
-    // Runs a call, authenticating (and re-authenticating after reconnects) as needed. Unlike
-    // call(), does NOT wait for account access.
+    // Runs a call, authenticating (and re-authenticating after reconnects) as needed. Unlike call(), does NOT wait for account access.
     private async callAuthed<T>(fnc: () => Promise<T>): Promise<T> {
         try {
             return await fnc();
@@ -97,9 +88,7 @@ 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.
+    // 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));
         if (state.hasAccess) return undefined;
@@ -116,8 +105,7 @@ export class ArchivesRemote implements IArchives {
         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
+    // 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));
         if (Date.now() - this.lastDeniedLog > timeInMinute) {
@@ -126,9 +114,7 @@ export class ArchivesRemote implements IArchives {
         }
     }
 
-    // Runs a call, authenticating (and re-authenticating after reconnects) and waiting for account
-    // access as needed. With waitForAccess false, denied calls throw immediately instead - but the
-    // access request is still registered (in the background), so the denial is grantable.
+    // Runs a call, authenticating (and re-authenticating after reconnects) and waiting for account access as needed. With waitForAccess false, denied calls throw immediately instead - but the access request is still registered (in the background), so the denial is grantable.
     private async call<T>(fnc: () => Promise<T>): Promise<T> {
         while (true) {
             try {
@@ -188,8 +174,7 @@ export class ArchivesRemote implements IArchives {
     }
 
     public async setLargeFile(config: { path: string; 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)
+        // 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);
         try {

package/storage/remoteStorage/ArchivesUrl.ts

@@ -5,8 +5,7 @@ import { IArchives, ArchiveFileInfo, ArchivesConfig } from "../IArchives";
 import { buildFileUrl } from "./remoteConfig";
 
 // Read-only IArchives over a public bucket's plain-URL form (our storage server's
-// /file/<account>/<bucketName>/... route, or a backblaze friendly URL). Used when we have no API
-// access to a source. Only single-file reads work: there is no listing, and writes always throw.
+// /file/<account>/<bucketName>/... route, or a backblaze friendly URL). Used when we have no API access to a source. Only single-file reads work: there is no listing, and writes always throw.
 
 export class ArchivesUrl implements IArchives {
     // base is the bucket's public base URL, e.g. https://host:port/file/<account>/<bucketName>
@@ -47,8 +46,7 @@ export class ArchivesUrl implements IArchives {
         if (total && Number.isFinite(total)) {
             size = total;
         }
-        // Servers that don't support ranges return the full file with a 200 (ours serves real
-        // 206s, but backblaze friendly URLs and proxies may not)
+        // Servers that don't support ranges return the full file with a 200 (ours serves real 206s, but backblaze friendly URLs and proxies may not)
         if (range && response.statusCode === 200) {
             data = data.subarray(Math.min(range.start, data.length), Math.min(range.end, data.length));
         }

package/storage/remoteStorage/accessPage.tsx

@@ -9,11 +9,7 @@ import { SocketFunction } from "socket-function/SocketFunction";
 import { RemoteStorageController, AccessState, AccessRequest } from "./storageController";
 import { authenticateStorage } from "./ArchivesRemote";
 
-// The storage server's access page. Visit https://<storageDomain>:<port>/<accountName> to request
-// access to that account for this browser's machine identity. Once granted, lists the machines that
-// have access. To approve someone else's request, the user must type in the requester's IP —
-// pending requests are NEVER shown unsolicited (so a trusted user can't accidentally approve a
-// random machine's request).
+// The storage server's access page. Visit https://<storageDomain>:<port>/<accountName> to request access to that account for this browser's machine identity. Once granted, lists the machines that have access. To approve someone else's request, the user must type in the requester's IP — pending requests are NEVER shown unsolicited (so a trusted user can't accidentally approve a random machine's request).
 
 const REFRESH_INTERVAL = 1000 * 15;
 const COPIED_RESET_DELAY = 2000;

package/storage/remoteStorage/blobStore.d.ts

@@ -78,6 +78,7 @@ export declare class BlobStore implements IBucketStore {
     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;
@@ -102,20 +103,12 @@ export declare class BlobStore implements IBucketStore {
     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];
@@ -134,8 +127,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). */
+    /** 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;