sliftutils 1.7.9 → 1.7.11

package/storage/dist/remoteFileStorage.ts.cache

@@ -0,0 +1,495 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.testRemoteConnection = exports.getRemoteDirectoryHandle = void 0;
+const typesafecss_1 = require("typesafecss");
+// 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;
+const DEFAULT_CACHE_BYTES = 128 * 1024 * 1024;
+function enoent(p) {
+    return Object.assign(new Error(`File not found: ${p}`), { code: "ENOENT", name: "NotFoundError" });
+}
+function toArrayBuffer(b) {
+    return b.buffer.slice(b.byteOffset, b.byteOffset + b.byteLength);
+}
+const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+// 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.
+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).
+const DEFAULT_MAX_FETCH_BYTES = 4 * 1024 * 1024;
+const STATS_LOG_INTERVAL_MS = 10 * 1000;
+const RECV_WINDOW_MS = 60 * 1000;
+function fmtBytes(n) {
+    if (n < 1024)
+        return n + "B";
+    if (n < 1024 * 1024)
+        return (n / 1024).toFixed(1) + "KB";
+    if (n < 1024 * 1024 * 1024)
+        return (n / 1024 / 1024).toFixed(1) + "MB";
+    return (n / 1024 / 1024 / 1024).toFixed(2) + "GB";
+}
+function makeWebSocket(url) {
+    if ((0, typesafecss_1.isNode)()) {
+        // `ws` is a Node dep; the eval hides it from the browser bundler (this branch never runs there).
+        const WS = eval("require")("ws");
+        return new WS(url, { rejectUnauthorized: false }); // self-signed cert
+    }
+    return new WebSocket(url);
+}
+// Binary frame: [u32 headerLen LE][header JSON][body bytes].
+function encodeFrame(header, body) {
+    const h = Buffer.from(JSON.stringify(header), "utf8");
+    const len = Buffer.alloc(4);
+    len.writeUInt32LE(h.length, 0);
+    return Buffer.concat([len, h, body || EMPTY]);
+}
+function decodeFrame(buf) {
+    const headerLen = buf.readUInt32LE(0);
+    const header = JSON.parse(buf.subarray(4, 4 + headerLen).toString("utf8"));
+    return { header, body: buf.subarray(4 + headerLen) };
+}
+// 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 {
+    constructor(url, password, opts) {
+        var _a, _b;
+        this.url = url;
+        this.password = password;
+        this.opts = opts;
+        this.infoCache = new Map();
+        this.nextId = 1;
+        this.pending = new Map();
+        this.queue = [];
+        this.inFlightBytes = 0;
+        this.receivedTotal = 0;
+        this.recvWindow = [];
+        this.url = url.replace(/\/+$/, "");
+        this.wsUrl = this.url.replace(/^http/, "ws"); // https→wss, http→ws
+        this.host = (() => { try {
+            return new URL(this.url).host;
+        }
+        catch (_a) {
+            return this.url;
+        } })();
+        this.cache = new RangeCache(opts.chunkBytes || DEFAULT_CHUNK_BYTES, opts.cacheBytes || DEFAULT_CACHE_BYTES, opts.maxFetchBytes || DEFAULT_MAX_FETCH_BYTES);
+        this.statsTimer = setInterval(() => this.logStats(), STATS_LOG_INTERVAL_MS);
+        (_b = (_a = this.statsTimer).unref) === null || _b === void 0 ? void 0 : _b.call(_a);
+    }
+    close() {
+        var _a;
+        clearInterval(this.statsTimer);
+        try {
+            (_a = this.ws) === null || _a === void 0 ? void 0 : _a.close();
+        }
+        catch ( /* */_b) { /* */ }
+        this.ws = undefined;
+        this.connecting = undefined;
+    }
+    logStats() {
+        const now = Date.now();
+        this.recvWindow = this.recvWindow.filter(e => now - e.t < RECV_WINDOW_MS);
+        if (this.inFlightBytes === 0 && this.queue.length === 0)
+            return; // only when there's traffic
+        const recv60 = this.recvWindow.reduce((a, e) => a + e.n, 0);
+        const queuedBytes = this.queue.reduce((a, q) => a + q.bytes, 0);
+        console.log(`[remote ${this.host}] outstanding ${fmtBytes(this.inFlightBytes)} (${this.pending.size} req), queued ${fmtBytes(queuedBytes)} (${this.queue.length} req), recv/60s ${fmtBytes(recv60)}, recv total ${fmtBytes(this.receivedTotal)}`);
+    }
+    ensureConnected() {
+        if (this.ws && this.ws.readyState === 1)
+            return Promise.resolve();
+        if (this.connecting)
+            return this.connecting;
+        this.connecting = new Promise((resolve, reject) => {
+            let authed = false;
+            const ws = makeWebSocket(this.wsUrl);
+            ws.binaryType = "arraybuffer";
+            this.ws = ws;
+            ws.onopen = () => ws.send(encodeFrame({ id: 0, op: "auth", password: this.password }));
+            ws.onmessage = (ev) => {
+                const buf = Buffer.isBuffer(ev.data) ? ev.data : Buffer.from(ev.data);
+                const { header } = decodeFrame(buf);
+                if (!authed && header.id === 0) {
+                    if (header.status === 200) {
+                        authed = true;
+                        resolve();
+                    }
+                    else {
+                        reject(new Error("remote: authentication failed"));
+                        try {
+                            ws.close();
+                        }
+                        catch ( /* */_a) { /* */ }
+                    }
+                    return;
+                }
+                this.onMessage(buf);
+            };
+            ws.onerror = () => { if (!authed)
+                reject(new Error("remote: websocket connection error")); };
+            ws.onclose = () => {
+                if (!authed)
+                    reject(new Error("remote: connection closed before authenticating"));
+                this.handleDisconnect();
+            };
+        });
+        // Let a failed connection be retried next time.
+        this.connecting.catch(() => { this.ws = undefined; this.connecting = undefined; });
+        return this.connecting;
+    }
+    onMessage(buf) {
+        const { header, body } = decodeFrame(buf);
+        const p = this.pending.get(header.id);
+        if (!p)
+            return;
+        this.pending.delete(header.id);
+        this.inFlightBytes -= p.bytes;
+        this.receivedTotal += body.length;
+        if (this.opts.stats)
+            this.opts.stats.bytesFetched += body.length;
+        this.recvWindow.push({ t: Date.now(), n: body.length });
+        p.resolve({ status: header.status, body });
+        this.drain();
+    }
+    handleDisconnect() {
+        const err = new Error("remote: websocket disconnected");
+        for (const p of this.pending.values())
+            p.reject(err);
+        for (const q of this.queue)
+            q.reject(err);
+        this.pending.clear();
+        this.queue = [];
+        this.inFlightBytes = 0;
+        this.ws = undefined;
+        this.connecting = undefined;
+    }
+    drain() {
+        while (this.queue.length && this.ws && this.ws.readyState === 1) {
+            const next = this.queue[0];
+            if (this.inFlightBytes > 0 && this.inFlightBytes + next.bytes > MAX_INFLIGHT_BYTES)
+                break; // hold the queue
+            this.queue.shift();
+            this.inFlightBytes += next.bytes;
+            this.pending.set(next.id, { resolve: next.resolve, reject: next.reject, bytes: next.bytes });
+            if (this.opts.stats)
+                this.opts.stats.requestCount++;
+            this.ws.send(next.frame);
+        }
+    }
+    // Sends one request over the WebSocket (queued + throttled). `bytes` is the expected payload size,
+    // used for the in-flight cap.
+    async request(op, params, body, bytes) {
+        if (this.opts.latencyMs)
+            await sleep(this.opts.latencyMs);
+        await this.ensureConnected();
+        const id = this.nextId++;
+        const frame = encodeFrame({ id, op, ...params }, body);
+        return new Promise((resolve, reject) => {
+            this.queue.push({ id, frame, bytes: Math.max(bytes, body ? body.length : 0, 1), resolve, reject });
+            this.drain();
+        });
+    }
+    async stat(path) {
+        const cached = this.infoCache.get(path);
+        if (cached && Date.now() - cached.at < INFO_TTL_MS)
+            return cached.stat;
+        const r = await this.request("info", { path }, undefined, 256);
+        let stat;
+        if (r.status === 404)
+            stat = undefined;
+        else if (r.status !== 200)
+            throw new Error(`remote info failed (${r.status})`);
+        else
+            stat = JSON.parse(r.body.toString("utf8"));
+        this.infoCache.set(path, { stat, at: Date.now() });
+        return stat;
+    }
+    async list(path) {
+        const r = await this.request("list", { path }, undefined, 4096);
+        if (r.status !== 200)
+            throw new Error(`remote list failed (${r.status})`);
+        return JSON.parse(r.body.toString("utf8"));
+    }
+    async read(path, start, end) {
+        var _a;
+        return (_a = (await this.cache.read(this, path, start, end))) !== null && _a !== void 0 ? _a : EMPTY;
+    }
+    async readServer(path, start, end) {
+        const r = await this.request("read", { path, start, end }, undefined, end - start);
+        if (r.status === 404)
+            return undefined;
+        if (r.status !== 200)
+            throw new Error(`remote read failed (${r.status})`);
+        return r.body;
+    }
+    async append(path, body) {
+        const r = await this.request("append", { path }, body, body.length);
+        if (r.status !== 200)
+            throw new Error(`remote append failed (${r.status})`);
+        this.infoCache.delete(path); // append-only keeps existing bytes; only the size changed
+    }
+    async set(path, body) {
+        const r = await this.request("set", { path }, body, body.length);
+        if (r.status !== 200)
+            throw new Error(`remote set failed (${r.status})`);
+        this.cache.invalidate(path);
+        this.infoCache.delete(path);
+    }
+    async remove(path) {
+        const r = await this.request("remove", { path }, undefined, 256);
+        if (r.status !== 200)
+            throw new Error(`remote remove failed (${r.status})`);
+        this.cache.invalidate(path);
+        this.infoCache.delete(path);
+    }
+}
+// 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 {
+    constructor(chunkBytes, budget, maxFetchBytes) {
+        this.chunkBytes = chunkBytes;
+        this.budget = budget;
+        this.maxFetchBytes = maxFetchBytes;
+        this.chunks = new Map(); // path + "
" + chunkIndex, insertion-ordered (LRU)
+        this.bytes = 0;
+    }
+    key(path, c) { return path + "
" + c; }
+    peek(path, c) {
+        const k = this.key(path, c);
+        const v = this.chunks.get(k);
+        if (v) {
+            this.chunks.delete(k);
+            this.chunks.set(k, v);
+        }
+        return v;
+    }
+    store(path, c, buf) {
+        const k = this.key(path, c);
+        const ex = this.chunks.get(k);
+        if (ex && ex.length >= buf.length) {
+            this.chunks.delete(k);
+            this.chunks.set(k, ex);
+            return;
+        }
+        if (ex)
+            this.bytes -= ex.length;
+        this.chunks.delete(k);
+        this.chunks.set(k, buf);
+        this.bytes += buf.length;
+        while (this.bytes > this.budget && this.chunks.size > 0) {
+            const oldest = this.chunks.keys().next().value;
+            this.bytes -= this.chunks.get(oldest).length;
+            this.chunks.delete(oldest);
+        }
+    }
+    invalidate(path) {
+        const prefix = path + "
";
+        for (const k of [...this.chunks.keys()])
+            if (k.startsWith(prefix)) {
+                this.bytes -= this.chunks.get(k).length;
+                this.chunks.delete(k);
+            }
+    }
+    async read(conn, path, start, end) {
+        if (end <= start)
+            return EMPTY;
+        const CHUNK = this.chunkBytes;
+        const maxRunChunks = Math.max(1, Math.floor(this.maxFetchBytes / CHUNK));
+        const firstChunk = Math.floor(start / CHUNK);
+        const lastChunk = Math.floor((end - 1) / CHUNK);
+        // Collect the chunks we don't have deeply enough into bounded contiguous runs (each <= maxFetchBytes).
+        const runs = [];
+        let runFrom = -1;
+        for (let c = firstChunk; c <= lastChunk; c++) {
+            const cStart = c * CHUNK;
+            const needEnd = Math.min(end, cStart + CHUNK) - cStart;
+            const have = this.peek(path, c);
+            if (!have || have.length < needEnd) {
+                if (runFrom < 0)
+                    runFrom = c;
+                if (c - runFrom + 1 >= maxRunChunks) {
+                    runs.push({ from: runFrom, to: c });
+                    runFrom = -1;
+                }
+            }
+            else if (runFrom >= 0) {
+                runs.push({ from: runFrom, to: c - 1 });
+                runFrom = -1;
+            }
+        }
+        if (runFrom >= 0)
+            runs.push({ from: runFrom, to: lastChunk });
+        // Fetch all runs concurrently; the connection's queue caps total in-flight bytes.
+        let missingFile = false;
+        await Promise.all(runs.map(async (run) => {
+            const bytes = await conn.readServer(path, run.from * CHUNK, (run.to + 1) * CHUNK);
+            if (bytes === undefined) {
+                missingFile = true;
+                return;
+            }
+            for (let c = run.from; c <= run.to; c++) {
+                const off = (c - run.from) * CHUNK;
+                if (off >= bytes.length)
+                    break;
+                this.store(path, c, bytes.subarray(off, Math.min(off + CHUNK, bytes.length)));
+            }
+        }));
+        if (missingFile)
+            return undefined;
+        const parts = [];
+        for (let c = firstChunk; c <= lastChunk; c++) {
+            const cStart = c * CHUNK;
+            const from = Math.max(start, cStart) - cStart;
+            const to = Math.min(end, cStart + CHUNK) - cStart;
+            const chunk = this.peek(path, c);
+            if (!chunk || chunk.length < to) {
+                if (chunk && chunk.length > from)
+                    parts.push(chunk.subarray(from, chunk.length));
+                break;
+            }
+            parts.push(chunk.subarray(from, to));
+        }
+        return parts.length === 1 ? parts[0] : Buffer.concat(parts);
+    }
+}
+const joinPath = (base, key) => (base ? base + "/" + key : key);
+const baseName = (p) => p.split("/").filter(Boolean).pop() || "";
+class RemoteFileWrapper {
+    // `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(conn, filePath, stat, createIntent = false) {
+        this.conn = conn;
+        this.filePath = filePath;
+        this.stat = stat;
+        this.createIntent = createIntent;
+        // Mirror the native FileSystemFileHandle shape so code written against it works unchanged.
+        this.kind = "file";
+    }
+    get name() { return baseName(this.filePath); }
+    async getFile() {
+        var _a;
+        let stat = (_a = this.stat) !== null && _a !== void 0 ? _a : await this.conn.stat(this.filePath);
+        if (!stat) {
+            if (!this.createIntent)
+                throw enoent(this.filePath);
+            stat = { size: 0, lastModified: Date.now(), dir: false };
+        }
+        const conn = this.conn, filePath = this.filePath, size = stat.size;
+        return {
+            size, lastModified: stat.lastModified,
+            async arrayBuffer() { return toArrayBuffer(await conn.read(filePath, 0, size)); },
+            slice(start, end) {
+                return { async arrayBuffer() { return toArrayBuffer(await conn.read(filePath, start, end)); } };
+            },
+        };
+    }
+    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.
+        return `${this.conn.url}/media?path=${encodeURIComponent(this.filePath)}&token=${encodeURIComponent(this.conn.password)}`;
+    }
+    async createWritable(config) {
+        const conn = this.conn, filePath = this.filePath, append = !!(config === null || config === void 0 ? void 0 : config.keepExistingData);
+        const chunks = [];
+        return {
+            async seek() { },
+            async write(value) { chunks.push(value); },
+            async close() {
+                const body = chunks.length === 1 ? chunks[0] : Buffer.concat(chunks);
+                if (append)
+                    await conn.append(filePath, body);
+                else
+                    await conn.set(filePath, body);
+            },
+        };
+    }
+}
+class RemoteDirectoryWrapper {
+    constructor(conn, dirPath) {
+        this.conn = conn;
+        this.dirPath = dirPath;
+        // 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.
+        this.kind = "directory";
+        this.isRemote = true;
+    }
+    get name() { return baseName(this.dirPath); }
+    get fullPath() { return this.dirPath; }
+    async removeEntry(key) {
+        await this.conn.remove(joinPath(this.dirPath, key));
+    }
+    async getFileHandle(key, options) {
+        const p = joinPath(this.dirPath, key);
+        if (options === null || options === void 0 ? void 0 : options.create)
+            return new RemoteFileWrapper(this.conn, p, undefined, true);
+        const stat = await this.conn.stat(p); // matches the File API: throw if missing
+        if (!stat || stat.dir)
+            throw enoent(p);
+        return new RemoteFileWrapper(this.conn, p, stat, false);
+    }
+    async getDirectoryHandle(key, options) {
+        const p = joinPath(this.dirPath, key);
+        if (!(options === null || options === void 0 ? void 0 : options.create)) {
+            const stat = await this.conn.stat(p);
+            if (!stat || !stat.dir)
+                throw enoent(p);
+        }
+        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.
+    async *[Symbol.asyncIterator]() {
+        const entries = await this.conn.list(this.dirPath);
+        for (const e of entries) {
+            const childPath = joinPath(this.dirPath, e.name);
+            yield [e.name, e.dir ? new RemoteDirectoryWrapper(this.conn, childPath) : new RemoteFileWrapper(this.conn, childPath)];
+        }
+    }
+    entries() { return this[Symbol.asyncIterator](); }
+    keys() { return mapAsync(this[Symbol.asyncIterator](), ([name]) => name); }
+    values() { return mapAsync(this[Symbol.asyncIterator](), ([, handle]) => handle); }
+}
+async function* mapAsync(it, fn) {
+    for await (const v of it)
+        yield fn(v);
+}
+// A DirectoryWrapper rooted at a remote server. Drop-in for the Node / File-API handles.
+function getRemoteDirectoryHandle(url, password, options = {}) {
+    return new RemoteDirectoryWrapper(new Connection(url, password, options), "");
+}
+exports.getRemoteDirectoryHandle = getRemoteDirectoryHandle;
+// 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).
+async function testRemoteConnection(url, password, options = {}) {
+    const conn = new Connection(url, password, options);
+    try {
+        await conn.list("");
+        return { status: "ok" };
+    }
+    catch (e) {
+        const msg = (e === null || e === void 0 ? void 0 : e.message) || String(e);
+        if (/auth/i.test(msg))
+            return { status: "unauthorized" };
+        return { status: "unreachable", error: msg };
+    }
+    finally {
+        conn.close();
+    }
+}
+exports.testRemoteConnection = testRemoteConnection;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"remoteFileStorage.js","sourceRoot":"","sources":["remoteFileStorage.ts"],"names":[],"mappings":"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","sourcesContent":["import { isNode } from \"typesafecss\";\nimport type { DirectoryWrapper, FileWrapper } from \"./FileFolderAPI\";\n\n// A remote server (remoteFileServer.js) exposed as a DirectoryWrapper — the SAME interface as the\n// Node.js and File-System-Access handles. So getDirectoryHandle can return one of these and everything\n// downstream (wrapHandle, navigation, BulkDatabase2) works unchanged; nothing else knows it's remote.\n//\n// Files here are immutable (written once) or append-only, so the range cache (raw compressed bytes, in\n// ~1MB aligned chunks) is always valid — over the network latency dominates, so reading 1MB costs about\n// the same as 64KB and far fewer round trips wins.\n\nconst EMPTY = Buffer.alloc(0);\nconst DEFAULT_CHUNK_BYTES = 1024 * 1024;\nconst DEFAULT_CACHE_BYTES = 128 * 1024 * 1024;\n\nexport type RemoteOptions = {\n    chunkBytes?: number;\n    cacheBytes?: number;\n    maxFetchBytes?: number;      // cap per read request; large reads split into this many bytes each\n    latencyMs?: number;          // artificial per-request delay, for simulating network latency in tests\n    stats?: { requestCount: number; bytesFetched: number };\n};\n\nfunction enoent(p: string): Error {\n    return Object.assign(new Error(`File not found: ${p}`), { code: \"ENOENT\", name: \"NotFoundError\" });\n}\nfunction toArrayBuffer(b: Buffer): ArrayBuffer {\n    return b.buffer.slice(b.byteOffset, b.byteOffset + b.byteLength) as ArrayBuffer;\n}\nconst sleep = (ms: number) => new Promise<void>(r => setTimeout(r, ms));\n\ntype Stat = { size: number; lastModified: number; dir: boolean };\n\n// A stat is cached this long, so the burst of size lookups during a single read pass is one request per\n// file, not one per block. Short enough that an append by another writer shows up promptly; our own\n// writes invalidate it immediately.\nconst INFO_TTL_MS = 2000;\n// We keep at most this many bytes of read/write requests in flight at once (the rest queue), so a big\n// read doesn't fire hundreds of MB of requests at the server simultaneously.\nconst MAX_INFLIGHT_BYTES = 64 * 1024 * 1024;\n// A single read request fetches at most this much; large reads are split into this many concurrent\n// requests (bounded by MAX_INFLIGHT_BYTES).\nconst DEFAULT_MAX_FETCH_BYTES = 4 * 1024 * 1024;\nconst STATS_LOG_INTERVAL_MS = 10 * 1000;\nconst RECV_WINDOW_MS = 60 * 1000;\n\nfunction fmtBytes(n: number): string {\n    if (n < 1024) return n + \"B\";\n    if (n < 1024 * 1024) return (n / 1024).toFixed(1) + \"KB\";\n    if (n < 1024 * 1024 * 1024) return (n / 1024 / 1024).toFixed(1) + \"MB\";\n    return (n / 1024 / 1024 / 1024).toFixed(2) + \"GB\";\n}\n\n// Minimal WebSocket surface common to the browser's WebSocket and the `ws` package.\ntype WSLike = {\n    readyState: number;\n    binaryType: string;\n    send(data: Uint8Array): void;\n    close(): void;\n    onopen: (() => void) | null;\n    onmessage: ((ev: { data: ArrayBuffer | Buffer }) => void) | null;\n    onclose: (() => void) | null;\n    onerror: ((e: unknown) => void) | null;\n};\nfunction makeWebSocket(url: string): WSLike {\n    if (isNode()) {\n        // `ws` is a Node dep; the eval hides it from the browser bundler (this branch never runs there).\n        const WS = (eval(\"require\") as NodeRequire)(\"ws\");\n        return new WS(url, { rejectUnauthorized: false }) as WSLike; // self-signed cert\n    }\n    return new WebSocket(url) as unknown as WSLike;\n}\n\n// Binary frame: [u32 headerLen LE][header JSON][body bytes].\nfunction encodeFrame(header: object, body?: Buffer): Buffer {\n    const h = Buffer.from(JSON.stringify(header), \"utf8\");\n    const len = Buffer.alloc(4);\n    len.writeUInt32LE(h.length, 0);\n    return Buffer.concat([len, h, body || EMPTY]);\n}\nfunction decodeFrame(buf: Buffer): { header: any; body: Buffer } {\n    const headerLen = buf.readUInt32LE(0);\n    const header = JSON.parse(buf.subarray(4, 4 + headerLen).toString(\"utf8\"));\n    return { header, body: buf.subarray(4 + headerLen) };\n}\n\ntype QueuedRequest = { id: number; frame: Buffer; bytes: number; resolve: (r: { status: number; body: Buffer }) => void; reject: (e: Error) => void };\n\n// One WebSocket to a remote server, multiplexing all ops over it. Requests are queued and only sent\n// while < MAX_INFLIGHT_BYTES are outstanding; every 10s (when there's traffic) it logs the queue depth\n// and throughput.\nclass Connection {\n    private cache: RangeCache;\n    private infoCache = new Map<string, { stat: Stat | undefined; at: number }>();\n\n    private ws: WSLike | undefined;\n    private connecting: Promise<void> | undefined;\n    private nextId = 1;\n    private pending = new Map<number, { resolve: (r: { status: number; body: Buffer }) => void; reject: (e: Error) => void; bytes: number }>();\n    private queue: QueuedRequest[] = [];\n    private inFlightBytes = 0;\n\n    private receivedTotal = 0;\n    private recvWindow: { t: number; n: number }[] = [];\n    private wsUrl: string;\n    private host: string;\n    private statsTimer: ReturnType<typeof setInterval>;\n\n    constructor(public url: string, public password: string, private opts: RemoteOptions) {\n        this.url = url.replace(/\\/+$/, \"\");\n        this.wsUrl = this.url.replace(/^http/, \"ws\"); // https→wss, http→ws\n        this.host = (() => { try { return new URL(this.url).host; } catch { return this.url; } })();\n        this.cache = new RangeCache(opts.chunkBytes || DEFAULT_CHUNK_BYTES, opts.cacheBytes || DEFAULT_CACHE_BYTES, opts.maxFetchBytes || DEFAULT_MAX_FETCH_BYTES);\n        this.statsTimer = setInterval(() => this.logStats(), STATS_LOG_INTERVAL_MS);\n        (this.statsTimer as { unref?: () => void }).unref?.();\n    }\n\n    close() {\n        clearInterval(this.statsTimer);\n        try { this.ws?.close(); } catch { /* */ }\n        this.ws = undefined;\n        this.connecting = undefined;\n    }\n\n    private logStats() {\n        const now = Date.now();\n        this.recvWindow = this.recvWindow.filter(e => now - e.t < RECV_WINDOW_MS);\n        if (this.inFlightBytes === 0 && this.queue.length === 0) return; // only when there's traffic\n        const recv60 = this.recvWindow.reduce((a, e) => a + e.n, 0);\n        const queuedBytes = this.queue.reduce((a, q) => a + q.bytes, 0);\n        console.log(`[remote ${this.host}] outstanding ${fmtBytes(this.inFlightBytes)} (${this.pending.size} req), queued ${fmtBytes(queuedBytes)} (${this.queue.length} req), recv/60s ${fmtBytes(recv60)}, recv total ${fmtBytes(this.receivedTotal)}`);\n    }\n\n    private ensureConnected(): Promise<void> {\n        if (this.ws && this.ws.readyState === 1) return Promise.resolve();\n        if (this.connecting) return this.connecting;\n        this.connecting = new Promise<void>((resolve, reject) => {\n            let authed = false;\n            const ws = makeWebSocket(this.wsUrl);\n            ws.binaryType = \"arraybuffer\";\n            this.ws = ws;\n            ws.onopen = () => ws.send(encodeFrame({ id: 0, op: \"auth\", password: this.password }));\n            ws.onmessage = (ev) => {\n                const buf = Buffer.isBuffer(ev.data) ? ev.data as Buffer : Buffer.from(ev.data as ArrayBuffer);\n                const { header } = decodeFrame(buf);\n                if (!authed && header.id === 0) {\n                    if (header.status === 200) { authed = true; resolve(); }\n                    else { reject(new Error(\"remote: authentication failed\")); try { ws.close(); } catch { /* */ } }\n                    return;\n                }\n                this.onMessage(buf);\n            };\n            ws.onerror = () => { if (!authed) reject(new Error(\"remote: websocket connection error\")); };\n            ws.onclose = () => {\n                if (!authed) reject(new Error(\"remote: connection closed before authenticating\"));\n                this.handleDisconnect();\n            };\n        });\n        // Let a failed connection be retried next time.\n        this.connecting.catch(() => { this.ws = undefined; this.connecting = undefined; });\n        return this.connecting;\n    }\n\n    private onMessage(buf: Buffer) {\n        const { header, body } = decodeFrame(buf);\n        const p = this.pending.get(header.id);\n        if (!p) return;\n        this.pending.delete(header.id);\n        this.inFlightBytes -= p.bytes;\n        this.receivedTotal += body.length;\n        if (this.opts.stats) this.opts.stats.bytesFetched += body.length;\n        this.recvWindow.push({ t: Date.now(), n: body.length });\n        p.resolve({ status: header.status, body });\n        this.drain();\n    }\n\n    private handleDisconnect() {\n        const err = new Error(\"remote: websocket disconnected\");\n        for (const p of this.pending.values()) p.reject(err);\n        for (const q of this.queue) q.reject(err);\n        this.pending.clear();\n        this.queue = [];\n        this.inFlightBytes = 0;\n        this.ws = undefined;\n        this.connecting = undefined;\n    }\n\n    private drain() {\n        while (this.queue.length && this.ws && this.ws.readyState === 1) {\n            const next = this.queue[0];\n            if (this.inFlightBytes > 0 && this.inFlightBytes + next.bytes > MAX_INFLIGHT_BYTES) break; // hold the queue\n            this.queue.shift();\n            this.inFlightBytes += next.bytes;\n            this.pending.set(next.id, { resolve: next.resolve, reject: next.reject, bytes: next.bytes });\n            if (this.opts.stats) this.opts.stats.requestCount++;\n            this.ws.send(next.frame);\n        }\n    }\n\n    // Sends one request over the WebSocket (queued + throttled). `bytes` is the expected payload size,\n    // used for the in-flight cap.\n    private async request(op: string, params: Record<string, unknown>, body: Buffer | undefined, bytes: number): Promise<{ status: number; body: Buffer }> {\n        if (this.opts.latencyMs) await sleep(this.opts.latencyMs);\n        await this.ensureConnected();\n        const id = this.nextId++;\n        const frame = encodeFrame({ id, op, ...params }, body);\n        return new Promise((resolve, reject) => {\n            this.queue.push({ id, frame, bytes: Math.max(bytes, body ? body.length : 0, 1), resolve, reject });\n            this.drain();\n        });\n    }\n\n    async stat(path: string): Promise<Stat | undefined> {\n        const cached = this.infoCache.get(path);\n        if (cached && Date.now() - cached.at < INFO_TTL_MS) return cached.stat;\n        const r = await this.request(\"info\", { path }, undefined, 256);\n        let stat: Stat | undefined;\n        if (r.status === 404) stat = undefined;\n        else if (r.status !== 200) throw new Error(`remote info failed (${r.status})`);\n        else stat = JSON.parse(r.body.toString(\"utf8\")) as Stat;\n        this.infoCache.set(path, { stat, at: Date.now() });\n        return stat;\n    }\n    async list(path: string): Promise<{ name: string; dir: boolean }[]> {\n        const r = await this.request(\"list\", { path }, undefined, 4096);\n        if (r.status !== 200) throw new Error(`remote list failed (${r.status})`);\n        return JSON.parse(r.body.toString(\"utf8\"));\n    }\n    async read(path: string, start: number, end: number): Promise<Buffer> {\n        return (await this.cache.read(this, path, start, end)) ?? EMPTY;\n    }\n    async readServer(path: string, start: number, end: number): Promise<Buffer | undefined> {\n        const r = await this.request(\"read\", { path, start, end }, undefined, end - start);\n        if (r.status === 404) return undefined;\n        if (r.status !== 200) throw new Error(`remote read failed (${r.status})`);\n        return r.body;\n    }\n    async append(path: string, body: Buffer): Promise<void> {\n        const r = await this.request(\"append\", { path }, body, body.length);\n        if (r.status !== 200) throw new Error(`remote append failed (${r.status})`);\n        this.infoCache.delete(path); // append-only keeps existing bytes; only the size changed\n    }\n    async set(path: string, body: Buffer): Promise<void> {\n        const r = await this.request(\"set\", { path }, body, body.length);\n        if (r.status !== 200) throw new Error(`remote set failed (${r.status})`);\n        this.cache.invalidate(path);\n        this.infoCache.delete(path);\n    }\n    async remove(path: string): Promise<void> {\n        const r = await this.request(\"remove\", { path }, undefined, 256);\n        if (r.status !== 200) throw new Error(`remote remove failed (${r.status})`);\n        this.cache.invalidate(path);\n        this.infoCache.delete(path);\n    }\n}\n\n// Caches the longest-known prefix of each aligned chunk per path. Valid because files are immutable or\n// append-only (the bytes at an offset never change). It only does range reads — it doesn't care what\n// the files are.\nclass RangeCache {\n    private chunks = new Map<string, Buffer>(); // path + \"\u0001\" + chunkIndex, insertion-ordered (LRU)\n    private bytes = 0;\n    constructor(private chunkBytes: number, private budget: number, private maxFetchBytes: number) { }\n    private key(path: string, c: number) { return path + \"\u0001\" + c; }\n    private peek(path: string, c: number): Buffer | undefined {\n        const k = this.key(path, c);\n        const v = this.chunks.get(k);\n        if (v) { this.chunks.delete(k); this.chunks.set(k, v); }\n        return v;\n    }\n    private store(path: string, c: number, buf: Buffer) {\n        const k = this.key(path, c);\n        const ex = this.chunks.get(k);\n        if (ex && ex.length >= buf.length) { this.chunks.delete(k); this.chunks.set(k, ex); return; }\n        if (ex) this.bytes -= ex.length;\n        this.chunks.delete(k);\n        this.chunks.set(k, buf);\n        this.bytes += buf.length;\n        while (this.bytes > this.budget && this.chunks.size > 0) {\n            const oldest = this.chunks.keys().next().value as string;\n            this.bytes -= (this.chunks.get(oldest) as Buffer).length;\n            this.chunks.delete(oldest);\n        }\n    }\n    invalidate(path: string) {\n        const prefix = path + \"\u0001\";\n        for (const k of [...this.chunks.keys()]) if (k.startsWith(prefix)) { this.bytes -= (this.chunks.get(k) as Buffer).length; this.chunks.delete(k); }\n    }\n    async read(conn: Connection, path: string, start: number, end: number): Promise<Buffer | undefined> {\n        if (end <= start) return EMPTY;\n        const CHUNK = this.chunkBytes;\n        const maxRunChunks = Math.max(1, Math.floor(this.maxFetchBytes / CHUNK));\n        const firstChunk = Math.floor(start / CHUNK);\n        const lastChunk = Math.floor((end - 1) / CHUNK);\n        // Collect the chunks we don't have deeply enough into bounded contiguous runs (each <= maxFetchBytes).\n        const runs: { from: number; to: number }[] = [];\n        let runFrom = -1;\n        for (let c = firstChunk; c <= lastChunk; c++) {\n            const cStart = c * CHUNK;\n            const needEnd = Math.min(end, cStart + CHUNK) - cStart;\n            const have = this.peek(path, c);\n            if (!have || have.length < needEnd) {\n                if (runFrom < 0) runFrom = c;\n                if (c - runFrom + 1 >= maxRunChunks) { runs.push({ from: runFrom, to: c }); runFrom = -1; }\n            } else if (runFrom >= 0) {\n                runs.push({ from: runFrom, to: c - 1 });\n                runFrom = -1;\n            }\n        }\n        if (runFrom >= 0) runs.push({ from: runFrom, to: lastChunk });\n        // Fetch all runs concurrently; the connection's queue caps total in-flight bytes.\n        let missingFile = false;\n        await Promise.all(runs.map(async run => {\n            const bytes = await conn.readServer(path, run.from * CHUNK, (run.to + 1) * CHUNK);\n            if (bytes === undefined) { missingFile = true; return; }\n            for (let c = run.from; c <= run.to; c++) {\n                const off = (c - run.from) * CHUNK;\n                if (off >= bytes.length) break;\n                this.store(path, c, bytes.subarray(off, Math.min(off + CHUNK, bytes.length)));\n            }\n        }));\n        if (missingFile) return undefined;\n        const parts: Buffer[] = [];\n        for (let c = firstChunk; c <= lastChunk; c++) {\n            const cStart = c * CHUNK;\n            const from = Math.max(start, cStart) - cStart;\n            const to = Math.min(end, cStart + CHUNK) - cStart;\n            const chunk = this.peek(path, c);\n            if (!chunk || chunk.length < to) { if (chunk && chunk.length > from) parts.push(chunk.subarray(from, chunk.length)); break; }\n            parts.push(chunk.subarray(from, to));\n        }\n        return parts.length === 1 ? parts[0] : Buffer.concat(parts);\n    }\n}\n\nconst joinPath = (base: string, key: string) => (base ? base + \"/\" + key : key);\nconst baseName = (p: string) => p.split(\"/\").filter(Boolean).pop() || \"\";\n\nclass RemoteFileWrapper implements FileWrapper {\n    // `stat` is supplied when the parent already statted us (avoids a second /info). `createIntent` means\n    // this was opened with create:true, so a missing file reads as empty (it'll be created on write).\n    constructor(private conn: Connection, private filePath: string, private stat?: Stat, private createIntent = false) { }\n    // Mirror the native FileSystemFileHandle shape so code written against it works unchanged.\n    readonly kind = \"file\" as const;\n    get name() { return baseName(this.filePath); }\n    async getFile() {\n        let stat = this.stat ?? await this.conn.stat(this.filePath);\n        if (!stat) {\n            if (!this.createIntent) throw enoent(this.filePath);\n            stat = { size: 0, lastModified: Date.now(), dir: false };\n        }\n        const conn = this.conn, filePath = this.filePath, size = stat.size;\n        return {\n            size, lastModified: stat.lastModified,\n            async arrayBuffer() { return toArrayBuffer(await conn.read(filePath, 0, size)); },\n            slice(start: number, end: number) {\n                return { async arrayBuffer() { return toArrayBuffer(await conn.read(filePath, start, end)); } };\n            },\n        };\n    }\n    async getURL() {\n        // HTTPS URL into the server's range-capable /media endpoint. The token rides in the query because a\n        // <video>/<img> element can't send an Authorization header.\n        return `${this.conn.url}/media?path=${encodeURIComponent(this.filePath)}&token=${encodeURIComponent(this.conn.password)}`;\n    }\n    async createWritable(config?: { keepExistingData?: boolean }) {\n        const conn = this.conn, filePath = this.filePath, append = !!config?.keepExistingData;\n        const chunks: Buffer[] = [];\n        return {\n            async seek() { /* the server appends to the end / overwrites the whole file; offset unused */ },\n            async write(value: Buffer) { chunks.push(value); },\n            async close() {\n                const body = chunks.length === 1 ? chunks[0] : Buffer.concat(chunks);\n                if (append) await conn.append(filePath, body); else await conn.set(filePath, body);\n            },\n        };\n    }\n}\n\nclass RemoteDirectoryWrapper implements DirectoryWrapper {\n    constructor(private conn: Connection, private dirPath: string) { }\n    // Mirror the native FileSystemDirectoryHandle shape (name/kind/entries) so code written against the\n    // native API — e.g. recursive walks using `handle.entries()` — works the same over the network.\n    readonly kind = \"directory\" as const;\n    readonly isRemote = true;\n    get name() { return baseName(this.dirPath); }\n    get fullPath() { return this.dirPath; }\n    async removeEntry(key: string): Promise<void> {\n        await this.conn.remove(joinPath(this.dirPath, key));\n    }\n    async getFileHandle(key: string, options?: { create?: boolean }): Promise<RemoteFileWrapper> {\n        const p = joinPath(this.dirPath, key);\n        if (options?.create) return new RemoteFileWrapper(this.conn, p, undefined, true);\n        const stat = await this.conn.stat(p);                 // matches the File API: throw if missing\n        if (!stat || stat.dir) throw enoent(p);\n        return new RemoteFileWrapper(this.conn, p, stat, false);\n    }\n    async getDirectoryHandle(key: string, options?: { create?: boolean }): Promise<RemoteDirectoryWrapper> {\n        const p = joinPath(this.dirPath, key);\n        if (!options?.create) {\n            const stat = await this.conn.stat(p);\n            if (!stat || !stat.dir) throw enoent(p);\n        }\n        return new RemoteDirectoryWrapper(this.conn, p);       // dirs are created lazily on first write\n    }\n    // Each entry is itself a real handle (a sub-wrapper), so a recursive walk over .entries() keeps\n    // working at every level — exactly like the native API.\n    async *[Symbol.asyncIterator](): AsyncIterableIterator<[string, RemoteFileWrapper | RemoteDirectoryWrapper]> {\n        const entries = await this.conn.list(this.dirPath);\n        for (const e of entries) {\n            const childPath = joinPath(this.dirPath, e.name);\n            yield [e.name, e.dir ? new RemoteDirectoryWrapper(this.conn, childPath) : new RemoteFileWrapper(this.conn, childPath)];\n        }\n    }\n    entries() { return this[Symbol.asyncIterator](); }\n    keys() { return mapAsync(this[Symbol.asyncIterator](), ([name]) => name); }\n    values() { return mapAsync(this[Symbol.asyncIterator](), ([, handle]) => handle); }\n}\n\nasync function* mapAsync<T, U>(it: AsyncIterableIterator<T>, fn: (v: T) => U): AsyncIterableIterator<U> {\n    for await (const v of it) yield fn(v);\n}\n\n// A DirectoryWrapper rooted at a remote server. Drop-in for the Node / File-API handles.\nexport function getRemoteDirectoryHandle(url: string, password: string, options: RemoteOptions = {}): DirectoryWrapper {\n    return new RemoteDirectoryWrapper(new Connection(url, password, options), \"\");\n}\n\nexport type RemoteConnectResult = { status: \"ok\" } | { status: \"unauthorized\" } | { status: \"unreachable\"; error: string };\n\n// Verifies a server is reachable and the password works — by opening the WebSocket, authenticating, and\n// listing the root. Distinguishes \"connected\" / \"wrong password\" / \"couldn't reach it\" (the last usually\n// meaning the self-signed cert isn't trusted yet in the browser, since the socket just fails to open).\nexport async function testRemoteConnection(url: string, password: string, options: RemoteOptions = {}): Promise<RemoteConnectResult> {\n    const conn = new Connection(url, password, options);\n    try {\n        await conn.list(\"\");\n        return { status: \"ok\" };\n    } catch (e) {\n        const msg = (e as Error)?.message || String(e);\n        if (/auth/i.test(msg)) return { status: \"unauthorized\" };\n        return { status: \"unreachable\", error: msg };\n    } finally {\n        conn.close();\n    }\n}\n"]}
+ /* _JS_SOURCE_HASH = "0ef349c55f3de629df041c02cbf7acac8b46362cc303e14843c801382938c8b6"; */