sliftutils 1.7.10 → 1.7.11

package/storage/dist/FileFolderAPI.tsx.cache

@@ -9,31 +9,89 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule && mod.default) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
-//exports.resetStorageLocation = exports.getFileStorage = exports.getFileStorageNested = exports.getDirectoryHandle = void 0;
+//exports.tryToLoadPointer = exports.getRemoteFileStorageFactory = exports.disposeFileURL = exports.getFileURL = exports.wrapHandle = exports.resetStorageLocation = exports.getFileStorage = exports.getFileStorageNested2 = exports.getFileStorageNested = exports.getDirectoryHandle = exports.pickPrivateFolder = exports.listPrivateFolders = exports.isPrivateFileSystemActive = exports.usePrivateFileSystem = exports.NodeJSDirectoryHandleWrapper = exports.NodeJSFileHandleWrapper = exports.setStorageRootOverride = exports.setFileAPIKey = void 0;
 const preact_1 = __importDefault(require("preact"));
 const fileSystemPointer_1 = require("./fileSystemPointer");
-const mobxTyped_1 = require("../misc/mobxTyped");
-const observer_1 = require("../misc/observer");
+const mobx_1 = require("mobx");
+const observer_1 = require("../render-utils/observer");
 const caching_1 = require("socket-function/src/caching");
 const typesafecss_1 = require("typesafecss");
 const batching_1 = require("socket-function/src/batching");
 const IndexedDBFileFolderAPI_1 = require("./IndexedDBFileFolderAPI");
+const remoteFileStorage_1 = require("./remoteFileStorage");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 // NOTE: IndexedDB is required for iOS, at least. We MIGHT want to make
 //  this a user supported toggle too, so they can choose during runtime if they want it.
 // DO NOT enable this is isNode
 const USE_INDEXED_DB = false;
-let displayData = (0, mobxTyped_1.observable)({
+// How often a worker rechecks the pointer IndexedDB for a granted handle when none is available yet.
+const WORKER_POLL_INTERVAL_MS = 60 * 1000;
+let displayData = (0, mobx_1.observable)({
     ui: undefined,
 }, undefined, { deep: false });
-const storageKey = "syncFileSystemCamera3";
+let fileAPIKey = "";
+function getFileAPIKey() {
+    if (!fileAPIKey)
+        throw new Error("Must call setFileAPIKey before using file system. Just pass any key. This prevents reusing the file system api that other development apps might be using.");
+    return fileAPIKey;
+}
+function setFileAPIKey(key) {
+    fileAPIKey = key;
+}
+exports.setFileAPIKey = setFileAPIKey;
+// A directory handle to serve as the storage root instead of resolving one via
+// the picker / stored-pointer / remote flow. Set this in a context that can't run
+// the interactive resolution — most importantly a Web Worker, which has no DOM to
+// prompt with and no localStorage pointer. The owning window resolves the handle
+// (with its permission grant) and postMessages it in; the worker calls this before
+// touching any storage. When set, getDirectoryHandle returns it directly and skips
+// every DOM / localStorage branch below.
+let storageRootOverride;
+function setStorageRootOverride(handle) {
+    storageRootOverride = handle;
+}
+exports.setStorageRootOverride = setStorageRootOverride;
+function remoteConfigKey() { return getFileAPIKey() + ":remote"; }
+function loadRemoteConfig() {
+    try {
+        const s = localStorage.getItem(remoteConfigKey());
+        if (!s)
+            return undefined;
+        const c = JSON.parse(s);
+        if (c && typeof c.url === "string" && typeof c.password === "string")
+            return c;
+    }
+    catch ( /* ignore */_a) { /* ignore */ }
+    return undefined;
+}
+function saveRemoteConfig(c) { localStorage.setItem(remoteConfigKey(), JSON.stringify(c)); }
+// The server is always HTTPS on the filehoster's default port, so the user only needs to type the host
+// (e.g. "65.109.93.113"). We strip any scheme/path they include and default the port if omitted.
+const DEFAULT_REMOTE_PORT = 8787; // matches remoteFileServer.js's default
+function normalizeServerUrl(raw) {
+    let s = raw.trim().replace(/^\w+:\/\//, "").replace(/\/.*$/, "");
+    if (!s)
+        return "";
+    if (!/:\d+$/.test(s))
+        s += ":" + DEFAULT_REMOTE_PORT;
+    return "https://" + s;
+}
+// One shared remote DirectoryWrapper (and therefore one shared range cache) per remote config.
+let remoteHandle;
+function getRemoteHandle(remote) {
+    const key = remote.url + "\0" + remote.password;
+    if (!remoteHandle || remoteHandle.key !== key) {
+        remoteHandle = { key, handle: (0, remoteFileStorage_1.getRemoteDirectoryHandle)(remote.url, remote.password) };
+    }
+    return remoteHandle.handle;
+}
 let DirectoryPrompter = class DirectoryPrompter extends preact_1.default.Component {
     render() {
         if (!displayData.ui)
             return undefined;
         return (preact_1.default.createElement("div", { className: typesafecss_1.css.position("fixed").pos(0, 0).size("100vw", "100vh")
-                .zIndex(1)
+                .zIndex(2147483647)
                 .background("white")
                 .center
                 .fontSize(40) }, displayData.ui));
@@ -42,21 +100,124 @@ let DirectoryPrompter = class DirectoryPrompter extends preact_1.default.Compone
 DirectoryPrompter = __decorate([
     observer_1.observer
 ], DirectoryPrompter);
+// "Connect to a server" option for the directory prompt: collapses to a button, expands to address +
+// password fields. On connect it ACTUALLY connects (testRemoteConnection); only on success does it
+// persist the config and call onConnected, so the caller (getDirectoryHandle) resolves with a working
+// remote handle. Failures are shown to the user (and logged, without the password), never swallowed.
+// `initial` pre-fills + expands the form (used to retry a remembered server that stopped working).
+let ServerConnectForm = class ServerConnectForm extends preact_1.default.Component {
+    constructor() {
+        var _a, _b;
+        super(...arguments);
+        this.obs = (0, mobx_1.observable)({
+            expanded: !!this.props.initial,
+            url: ((_a = this.props.initial) === null || _a === void 0 ? void 0 : _a.url) || "",
+            password: ((_b = this.props.initial) === null || _b === void 0 ? void 0 : _b.password) || "",
+            error: "", connecting: false, needsCert: false, showPassword: false,
+        });
+        this.connect = async () => {
+            const s = this.obs;
+            s.error = "";
+            s.needsCert = false;
+            s.connecting = true;
+            try {
+                const url = this.cleanUrl();
+                if (!url) {
+                    s.error = "Enter a server address.";
+                    return;
+                }
+                const result = await (0, remoteFileStorage_1.testRemoteConnection)(url, s.password.trim());
+                if (result.status === "ok") {
+                    const config = { url, password: s.password.trim() };
+                    saveRemoteConfig(config); // remember for next session
+                    this.props.onConnected(config); // hand the verified server back to getDirectoryHandle
+                    return;
+                }
+                if (result.status === "unauthorized") {
+                    s.error = "The server rejected that password.";
+                    console.error("Remote connect: unauthorized for", url);
+                }
+                else {
+                    // Got nothing back — usually the self-signed certificate isn't trusted yet, but show the
+                    // actual error too so a wrong address / down server / CORS issue is diagnosable.
+                    s.needsCert = true;
+                    s.error = "Couldn't reach the server: " + result.error;
+                    console.error("Remote connect: unreachable", url, "-", result.error);
+                }
+            }
+            catch (e) {
+                s.error = "Connection error: " + (e.message || String(e));
+                console.error("Remote connect threw:", e);
+            }
+            finally {
+                s.connecting = false;
+            }
+        };
+    }
+    cleanUrl() { return normalizeServerUrl(this.obs.url); }
+    render() {
+        const s = this.obs;
+        const inputCss = typesafecss_1.css.fontSize(28).pad2(24, 14).width(560).maxWidth("80vw");
+        const btnCss = typesafecss_1.css.fontSize(32).pad2(60, 30);
+        if (!s.expanded) {
+            return preact_1.default.createElement("button", { className: btnCss, onClick: () => s.expanded = true }, "Connect to a server");
+        }
+        return (preact_1.default.createElement("div", { className: typesafecss_1.css.vbox(16).center },
+            preact_1.default.createElement("input", { className: inputCss, placeholder: "server address (e.g. 65.109.93.113, or host:port)", value: s.url, onInput: e => s.url = e.target.value }),
+            preact_1.default.createElement("div", { className: typesafecss_1.css.hbox(10).center },
+                preact_1.default.createElement("input", { className: inputCss, type: s.showPassword ? "text" : "password", placeholder: "password (six words)", value: s.password, onInput: e => s.password = e.target.value }),
+                preact_1.default.createElement("button", { className: typesafecss_1.css.fontSize(22).pad2(24, 12), onClick: () => s.showPassword = !s.showPassword }, s.showPassword ? "Hide" : "Show")),
+            s.error ? preact_1.default.createElement("div", { className: typesafecss_1.css.fontSize(22).color("red").maxWidth("80vw") }, s.error) : null,
+            s.needsCert ? (preact_1.default.createElement("div", { className: typesafecss_1.css.vbox(10).center.fontSize(20).maxWidth(620).maxWidth("80vw").textAlign("center").color("hsl(0, 0%, 25%)") },
+                preact_1.default.createElement("div", null, "This server uses a self-signed certificate, so your browser has to trust it once:"),
+                preact_1.default.createElement("div", null, "1. Open the server in a new tab (button below). \u00A0 2. Accept the security warning (Advanced \u2192 Proceed). \u00A0 3. Come back and click Retry."),
+                preact_1.default.createElement("button", { className: typesafecss_1.css.fontSize(26).pad2(40, 20), onClick: () => { const u = this.cleanUrl(); if (u)
+                        window.open(u + "/", "_blank"); } }, "Open server & accept certificate"))) : null,
+            preact_1.default.createElement("div", { className: typesafecss_1.css.hbox(16) },
+                preact_1.default.createElement("button", { className: btnCss, disabled: s.connecting, onClick: this.connect }, s.connecting ? "Connecting…" : s.needsCert ? "Retry" : "Connect"),
+                preact_1.default.createElement("button", { className: btnCss, onClick: () => { s.expanded = false; s.error = ""; s.needsCert = false; } }, "Back"))));
+    }
+};
+ServerConnectForm = __decorate([
+    observer_1.observer
+], ServerConnectForm);
 class NodeJSFileHandleWrapper {
     constructor(filePath) {
         this.filePath = filePath;
+        this.kind = "file";
     }
+    get name() { return path_1.default.basename(this.filePath); }
     async getFile() {
         const stats = await fs_1.default.promises.stat(this.filePath);
+        const filePath = this.filePath;
         return {
             size: stats.size,
             lastModified: stats.mtimeMs,
             arrayBuffer: async () => {
-                const buffer = await fs_1.default.promises.readFile(this.filePath);
+                const buffer = await fs_1.default.promises.readFile(filePath);
                 return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
-            }
+            },
+            slice: (start, end) => ({
+                arrayBuffer: async () => {
+                    const clampedStart = Math.min(Math.max(start, 0), stats.size);
+                    const clampedEnd = Math.min(Math.max(end, clampedStart), stats.size);
+                    const length = clampedEnd - clampedStart;
+                    const fileHandle = await fs_1.default.promises.open(filePath, "r");
+                    try {
+                        const buffer = Buffer.alloc(length);
+                        await fileHandle.read(buffer, 0, length, clampedStart);
+                        return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+                    }
+                    finally {
+                        await fileHandle.close();
+                    }
+                }
+            })
         };
     }
+    async getURL() {
+        return "file://" + path_1.default.resolve(this.filePath);
+    }
     async createWritable(config) {
         let fileHandle;
         const flags = (config === null || config === void 0 ? void 0 : config.keepExistingData) ? "r+" : "w";
@@ -84,10 +245,15 @@ class NodeJSFileHandleWrapper {
         };
     }
 }
+exports.NodeJSFileHandleWrapper = NodeJSFileHandleWrapper;
 class NodeJSDirectoryHandleWrapper {
     constructor(rootPath) {
         this.rootPath = rootPath;
+        this.kind = "directory";
     }
+    get name() { return path_1.default.basename(this.rootPath); }
+    get fullPath() { return this.rootPath; }
+    entries() { return this[Symbol.asyncIterator](); }
     async removeEntry(key, options) {
         const entryPath = path_1.default.join(this.rootPath, key);
         if (options === null || options === void 0 ? void 0 : options.recursive) {
@@ -107,7 +273,12 @@ class NodeJSDirectoryHandleWrapper {
             await fs_1.default.promises.writeFile(filePath, Buffer.alloc(0));
         }
         else if (!exists) {
-            throw new Error(`File not found: ${filePath}`);
+            // Tag as ENOENT so readWithRetry treats it as a genuinely-missing file (return undefined now)
+            // rather than a transient read failure to retry 6× with backoff — missing files are normal
+            // (a concurrent merge deletes a file mid-read), and retrying them is catastrophically slow.
+            const err = new Error(`File not found: ${filePath}`);
+            err.code = "ENOENT";
+            throw err;
         }
         return new NodeJSFileHandleWrapper(filePath);
     }
@@ -129,66 +300,194 @@ class NodeJSDirectoryHandleWrapper {
         await fs_1.default.promises.mkdir(this.rootPath, { recursive: true });
         const entries = await fs_1.default.promises.readdir(this.rootPath, { withFileTypes: true });
         for (const entry of entries) {
+            const childPath = path_1.default.join(this.rootPath, entry.name);
             if (entry.isFile()) {
-                yield [entry.name, {
-                        kind: "file",
-                        name: entry.name,
-                        getFile: async () => new NodeJSFileHandleWrapper(path_1.default.join(this.rootPath, entry.name))
-                    }];
+                yield [entry.name, new NodeJSFileHandleWrapper(childPath)];
             }
             else if (entry.isDirectory()) {
-                const dirPath = path_1.default.join(this.rootPath, entry.name);
-                yield [entry.name, {
-                        kind: "directory",
-                        name: entry.name,
-                        getDirectoryHandle: async (key, options) => {
-                            return new NodeJSDirectoryHandleWrapper(dirPath).getDirectoryHandle(key, options);
-                        }
-                    }];
+                yield [entry.name, new NodeJSDirectoryHandleWrapper(childPath)];
             }
         }
     }
 }
-// NOTE: Blocks until the user provides a directory
+exports.NodeJSDirectoryHandleWrapper = NodeJSDirectoryHandleWrapper;
+// When set, getDirectoryHandle skips every prompt + remote check and serves from the browser's Origin
+// Private File System (OPFS). One named subfolder is "current" per fileAPIKey; pickPrivateFolder /
+// resetStorageLocation switch which one. Set this in app startup BEFORE the first getDirectoryHandle.
+let opfsEnabled = false;
+const OPFS_FOLDERS_DIR = "folders";
+const OPFS_DEFAULT_FOLDER = "default";
+function opfsCurrentKey() { return getFileAPIKey() + ":opfs:current"; }
+function getCurrentOpfsFolder() {
+    return localStorage.getItem(opfsCurrentKey()) || OPFS_DEFAULT_FOLDER;
+}
+function setCurrentOpfsFolder(name) {
+    localStorage.setItem(opfsCurrentKey(), name);
+}
+// Switches getDirectoryHandle to the Origin Private File System. No directory picker, no permission
+// prompt, no remote server check. Persists nothing — call on every app start before reading storage.
+function usePrivateFileSystem() {
+    opfsEnabled = true;
+}
+exports.usePrivateFileSystem = usePrivateFileSystem;
+// Whether the OPFS branch is in effect (so other callers can adapt — e.g. skip the "find data subdir"
+// hack in getFileStorageNested2 since OPFS is always a clean root we own end-to-end).
+function isPrivateFileSystemActive() {
+    return opfsEnabled;
+}
+exports.isPrivateFileSystemActive = isPrivateFileSystemActive;
+async function getOpfsFoldersDir() {
+    var _a;
+    if (!((_a = navigator.storage) === null || _a === void 0 ? void 0 : _a.getDirectory)) {
+        throw new Error("Private File System Access API not supported in this browser");
+    }
+    if (location.protocol === "file:") {
+        throw new Error("Private File System API is disallowed in file:// locations. Host on an actual origin.");
+    }
+    const root = await navigator.storage.getDirectory();
+    const keyed = await root.getDirectoryHandle(getFileAPIKey(), { create: true });
+    return await keyed.getDirectoryHandle(OPFS_FOLDERS_DIR, { create: true });
+}
+async function getCurrentOpfsHandle() {
+    const folders = await getOpfsFoldersDir();
+    const folder = await folders.getDirectoryHandle(getCurrentOpfsFolder(), { create: true });
+    return folder;
+}
+// All previously-used OPFS subfolders under this fileAPIKey, sorted alphabetically (timestamp-named
+// auto-generated folders therefore sort chronologically). Use this to surface a list, then call
+// pickPrivateFolder(name) to switch.
+async function listPrivateFolders() {
+    var _a;
+    if (!((_a = navigator.storage) === null || _a === void 0 ? void 0 : _a.getDirectory))
+        return [];
+    let folders;
+    try {
+        folders = await getOpfsFoldersDir();
+    }
+    catch (_b) {
+        return [];
+    }
+    const names = [];
+    for await (const [name, handle] of folders) {
+        if (handle.kind === "directory")
+            names.push(name);
+    }
+    return names.sort();
+}
+exports.listPrivateFolders = listPrivateFolders;
+// Switch to a specific OPFS subfolder and reload so getDirectoryHandle re-resolves to it. The folder
+// is created if it doesn't exist yet.
+function pickPrivateFolder(name) {
+    setCurrentOpfsFolder(name);
+    window.location.reload();
+}
+exports.pickPrivateFolder = pickPrivateFolder;
+// Returns the directory handle to use — local (Node / picked folder) OR a remote server, both as the
+// same DirectoryWrapper, so callers don't know or care which it is. A remembered server is VERIFIED
+// (we actually connect) before use; if it no longer works we re-prompt, just like a local folder whose
+// permission was lost. Blocks until ready (or the user dismisses, which rejects).
 exports.getDirectoryHandle = (0, caching_1.lazy)(async function getDirectoryHandle() {
+    // An injected root (e.g. a Web Worker handed the handle by its owning window)
+    // short-circuits the whole interactive resolution — no picker, no DOM, no
+    // localStorage. Must come first so a worker never reaches the branches below.
+    if (storageRootOverride) {
+        return storageRootOverride;
+    }
+    // A worker can't show the picker (no DOM / no user activation) and can't read localStorage, but
+    // it CAN open the pointer IndexedDB the main-thread picker persists to. Poll it for a handle
+    // whose permission is already granted; the owning window may also postMessage a handle in
+    // mid-poll (checked each iteration). This has to come before the isNode branch: typesafecss's
+    // isNode() returns true in workers (window is undefined), so a worker would otherwise fall into
+    // the Node branch and try to use fs/path.
+    if ("WorkerGlobalScope" in globalThis) {
+        while (true) {
+            if (storageRootOverride)
+                return storageRootOverride;
+            let handle = await (0, fileSystemPointer_1.findGrantedPointerHandle)("readwrite");
+            if (handle)
+                return handle;
+            await new Promise(resolve => setTimeout(resolve, WORKER_POLL_INTERVAL_MS));
+        }
+    }
     if ((0, typesafecss_1.isNode)()) {
         return new NodeJSDirectoryHandleWrapper(path_1.default.resolve("./data/"));
     }
+    if (opfsEnabled) {
+        return getCurrentOpfsHandle();
+    }
+    // A server connected in a previous session: only reuse it if it still actually works.
+    const savedRemote = loadRemoteConfig();
+    if (savedRemote) {
+        const result = await (0, remoteFileStorage_1.testRemoteConnection)(savedRemote.url, savedRemote.password);
+        if (result.status === "ok")
+            return getRemoteHandle(savedRemote);
+        console.warn(`Saved remote server didn't connect (${result.status})${result.status === "unreachable" ? ": " + result.error : ""} — re-prompting.`);
+    }
     let root = document.createElement("div");
     document.body.appendChild(root);
     preact_1.default.render(preact_1.default.createElement(DirectoryPrompter, null), root);
     try {
-        let handle;
-        let storedId = localStorage.getItem(storageKey);
+        let resolveHandle;
+        let rejectHandle;
+        const promise = new Promise((res, rej) => { resolveHandle = res; rejectHandle = rej; });
+        const pickLocal = async () => {
+            try {
+                const handle = await window.showDirectoryPicker();
+                await handle.requestPermission({ mode: "readwrite" });
+                const storedId = await (0, fileSystemPointer_1.storeFileSystemPointer)({ mode: "readwrite", handle });
+                localStorage.setItem(getFileAPIKey(), storedId);
+                resolveHandle(handle);
+            }
+            catch (e) {
+                console.error("Directory pick failed/cancelled:", e); // stay on the prompt
+            }
+        };
+        const onConnected = (config) => { saveRemoteConfig(config); resolveHandle(getRemoteHandle(config)); };
+        // The three options, rendered fresh each time. If a saved server just failed, pre-fill + expand
+        // the connect form so the user can retry or fix it.
+        const renderOptions = () => (preact_1.default.createElement(preact_1.default.Fragment, null,
+            preact_1.default.createElement("button", { className: typesafecss_1.css.fontSize(40).pad2(80, 40), onClick: pickLocal }, "Pick Data Directory"),
+            preact_1.default.createElement(ServerConnectForm, { onConnected: onConnected, initial: savedRemote }),
+            preact_1.default.createElement("button", { className: typesafecss_1.css.fontSize(40).pad2(80, 40), onClick: () => rejectHandle(new Error("User dismissed file system access prompt")) }, "Dismiss")));
+        // A previously-picked local folder: try to restore it (may need a click). Skipped when a saved
+        // server failed — that user wants the server, so go straight to the (pre-filled) prompt.
+        const storedId = !savedRemote && localStorage.getItem(getFileAPIKey());
         if (storedId) {
             let doneLoad = false;
-            setTimeout(() => {
-                if (doneLoad)
-                    return;
-                console.log("Waiting for user to click");
-                displayData.ui = "Click anywhere to allow file system access";
-            }, 500);
+            setTimeout(() => { if (!doneLoad)
+                displayData.ui = "Click anywhere to allow file system access"; }, 500);
             try {
-                handle = await tryToLoadPointer(storedId);
+                const handle = await tryToLoadPointer(storedId);
+                doneLoad = true;
+                if (handle)
+                    return handle;
             }
-            catch (_a) { }
-            doneLoad = true;
-            if (handle) {
-                return handle;
+            catch (e) {
+                doneLoad = true;
+                console.error(e);
+                const msg = e instanceof Error ? e.message : String(e);
+                if (msg.includes("user activation") || msg.includes("User activation")) {
+                    displayData.ui = (preact_1.default.createElement("div", { className: typesafecss_1.css.vbox(20).center },
+                        preact_1.default.createElement("button", { className: typesafecss_1.css.fontSize(40).pad2(80, 40), onClick: async () => {
+                                displayData.ui = "Loading...";
+                                try {
+                                    const h = await tryToLoadPointer(storedId);
+                                    if (h) {
+                                        resolveHandle(h);
+                                        return;
+                                    }
+                                }
+                                catch (retryError) {
+                                    console.error("Retry failed:", retryError);
+                                }
+                                displayData.ui = preact_1.default.createElement("div", { className: typesafecss_1.css.vbox(20).center }, renderOptions());
+                            } }, "Click to restore file system access"),
+                        renderOptions()));
+                    return await promise;
+                }
             }
         }
-        let fileCallback;
-        let promise = new Promise(resolve => {
-            fileCallback = resolve;
-        });
-        displayData.ui = (preact_1.default.createElement("button", { className: typesafecss_1.css.fontSize(40).pad2(80, 40), onClick: async () => {
-                console.log("Waiting for user to give permission");
-                const handle = await window.showDirectoryPicker();
-                await handle.requestPermission({ mode: "readwrite" });
-                let storedId = await (0, fileSystemPointer_1.storeFileSystemPointer)({ mode: "readwrite", handle });
-                localStorage.setItem(storageKey, storedId);
-                fileCallback(handle);
-            } }, "Pick Media Directory"));
+        displayData.ui = preact_1.default.createElement("div", { className: typesafecss_1.css.vbox(20).center }, renderOptions());
         return await promise;
     }
     finally {
@@ -205,6 +504,42 @@ exports.getFileStorageNested = (0, caching_1.cache)(async function getFileStorag
     }
     return wrapHandle(base);
 });
+// Supports if the user selects the folder that contains the data folder or the data folder directly. If pathStr is an absolute path (and we're in nodejs) we use it directly.
+exports.getFileStorageNested2 = (0, caching_1.cache)(async function getFileStorage(pathStr) {
+    let base;
+    pathStr = pathStr.replaceAll("\\", "/");
+    if ((0, typesafecss_1.isNode)()) {
+        if (path_1.default.isAbsolute(pathStr)) {
+            return wrapHandle(new NodeJSDirectoryHandleWrapper(pathStr));
+        }
+        base = new NodeJSDirectoryHandleWrapper(path_1.default.resolve("./data/"));
+    }
+    else {
+        base = await (0, exports.getDirectoryHandle)();
+        // Skip the "find data subdir" hack under OPFS — that's for picked directories where the user
+        // might have selected a folder with unrelated files; OPFS is a clean root we own end-to-end.
+        if (!opfsEnabled) {
+            let dirs = [];
+            let alls = [];
+            for await (const [name, entry] of base) {
+                if (entry.kind === "directory") {
+                    dirs.push(name);
+                }
+                alls.push(name);
+            }
+            // HACK: If there are enough files, it's almost certainly not a directory that contains collections. It's probably the user's data instead
+            if (dirs.includes(".git") || dirs.includes("data") || alls.length > 100) {
+                base = await base.getDirectoryHandle("data", { create: true });
+            }
+        }
+    }
+    for (let part of pathStr.split("/")) {
+        if (!part)
+            continue;
+        base = await base.getDirectoryHandle(part, { create: true });
+    }
+    return wrapHandle(base);
+});
 exports.getFileStorage = (0, caching_1.lazy)(async function getFileStorage() {
     if (USE_INDEXED_DB) {
         return await (0, IndexedDBFileFolderAPI_1.getFileStorageIndexDB)();
@@ -213,7 +548,18 @@ exports.getFileStorage = (0, caching_1.lazy)(async function getFileStorage() {
     return wrapHandle(handle);
 });
 function resetStorageLocation() {
-    localStorage.removeItem(storageKey);
+    if (opfsEnabled) {
+        // Don't delete previous folder — listPrivateFolders / pickPrivateFolder still need it. Just point
+        // "current" at a fresh timestamp-named one so the next reload starts clean.
+        setCurrentOpfsFolder(new Date().toISOString().replace(/[:.]/g, "-"));
+        window.location.reload();
+        return;
+    }
+    localStorage.removeItem(getFileAPIKey());
+    try {
+        localStorage.removeItem(remoteConfigKey());
+    }
+    catch ( /* ignore */_a) { /* ignore */ }
     window.location.reload();
 }
 exports.resetStorageLocation = resetStorageLocation;
@@ -234,31 +580,78 @@ async function fixedGetFileHandle(config) {
     }
     return await config.handle.getFileHandle(config.key, { create: true });
 }
+// A file that genuinely does not exist. We must NOT retry these, otherwise reading many missing
+// files (a common pattern) gets catastrophically slow.
+function isMissingError(error) {
+    let name = error === null || error === void 0 ? void 0 : error.name;
+    let code = error === null || error === void 0 ? void 0 : error.code;
+    return name === "NotFoundError" || code === "ENOENT";
+}
+const MAX_READ_RETRIES = 6;
+// The browser File System Access API can transiently fail reads under heavy load (it appears to
+// throttle when a page issues many reads at once). Those failures surface as errors OTHER than
+// "not found", so we retry them with backoff. A real missing file (NotFoundError / ENOENT) returns
+// undefined immediately with no retry.
+async function readWithRetry(label, key, read) {
+    let backoff = 25;
+    for (let attempt = 0;; attempt++) {
+        try {
+            return await read();
+        }
+        catch (error) {
+            if (isMissingError(error))
+                return undefined;
+            let name = (error === null || error === void 0 ? void 0 : error.name) || "Error";
+            let message = (error === null || error === void 0 ? void 0 : error.message) || String(error);
+            if (attempt >= MAX_READ_RETRIES) {
+                console.warn(`${label} gave up on ${JSON.stringify(key)} after ${attempt} retries (${name}): ${message.slice(0, 200)}`);
+                return undefined;
+            }
+            console.warn(`${label} retrying ${JSON.stringify(key)} (attempt ${attempt + 1}, ${name}): ${message.slice(0, 200)}`);
+            await new Promise(resolve => setTimeout(resolve, backoff));
+            backoff = Math.min(backoff * 2, 1000);
+        }
+    }
+}
 function wrapHandleFiles(handle) {
+    // Log the full path (root + filename) when available, so a failing file is identifiable.
+    const pathOf = (key) => handle.fullPath ? handle.fullPath + "/" + key : key;
     return {
         async getInfo(key) {
-            try {
+            return readWithRetry("getInfo", pathOf(key), async () => {
                 const file = await handle.getFileHandle(key);
                 const fileContent = await file.getFile();
                 return {
                     size: fileContent.size,
                     lastModified: fileContent.lastModified,
                 };
-            }
-            catch (error) {
-                return undefined;
-            }
+            });
         },
         async get(key) {
-            try {
+            return readWithRetry("get", pathOf(key), async () => {
                 const file = await handle.getFileHandle(key);
                 const fileContent = await file.getFile();
                 const arrayBuffer = await fileContent.arrayBuffer();
+                // Under load the FS Access API can resolve with a truncated buffer and no error.
+                //  Treat a short read as transient so readWithRetry retries it.
+                if (arrayBuffer.byteLength !== fileContent.size) {
+                    throw Object.assign(new Error(`Short read: got ${arrayBuffer.byteLength} of ${fileContent.size} bytes`), { name: "ShortReadError" });
+                }
                 return Buffer.from(arrayBuffer);
-            }
-            catch (error) {
-                return undefined;
-            }
+            });
+        },
+        async getRange(key, config) {
+            return readWithRetry("getRange", pathOf(key), async () => {
+                const file = await handle.getFileHandle(key);
+                const fileContent = await file.getFile();
+                const clampedStart = Math.min(Math.max(config.start, 0), fileContent.size);
+                const clampedEnd = Math.min(Math.max(config.end, clampedStart), fileContent.size);
+                const arrayBuffer = await fileContent.slice(config.start, config.end).arrayBuffer();
+                if (arrayBuffer.byteLength !== clampedEnd - clampedStart) {
+                    throw Object.assign(new Error(`Short range read: got ${arrayBuffer.byteLength} of ${clampedEnd - clampedStart} bytes`), { name: "ShortReadError" });
+                }
+                return Buffer.from(arrayBuffer);
+            });
         },
         async append(key, value) {
             await appendQueue(key)(async () => {
@@ -281,13 +674,22 @@ function wrapHandleFiles(handle) {
         async remove(key) {
             await handle.removeEntry(key);
         },
-        async getKeys() {
+        async getKeys(includeFolders = false) {
             const keys = [];
-            for await (const [name, entry] of handle) {
-                if (entry.kind === "file") {
-                    keys.push(entry.name);
+            try {
+                for await (const [name, entry] of handle) {
+                    if (entry.kind === "file" || includeFolders) {
+                        keys.push(entry.name);
+                    }
                 }
             }
+            catch (error) {
+                let name = (error === null || error === void 0 ? void 0 : error.name) || "Error";
+                let message = (error === null || error === void 0 ? void 0 : error.message) || String(error);
+                // A failure mid-iteration would silently truncate the listing, so surface it loudly.
+                console.error(`getKeys directory iteration failed after ${keys.length} entries (${name}): ${message.slice(0, 300)}`);
+                throw error;
+            }
             return keys;
         },
         async reset() {
@@ -330,8 +732,48 @@ function wrapHandle(handle) {
     return {
         ...wrapHandleFiles(handle),
         folder: wrapHandleNested(handle),
+        isRemote: handle.isRemote,
+    };
+}
+exports.wrapHandle = wrapHandle;
+// Returns a URL for a file's bytes, ready to drop into <video>/<img>/fetch. A native (local) file becomes
+// an in-memory blob: URL; a remote file becomes an https URL into the server's range-capable /media
+// endpoint (auth token in the query, since a media element can't send headers). Both support HTTP range /
+// seeking. ALWAYS hand the result to disposeFileURL when finished — for blob: URLs that frees memory.
+async function getFileURL(file) {
+    if (file.getURL)
+        return file.getURL();
+    // Native FileSystemFileHandle (or any Blob-backed file): a blob: URL over the File itself.
+    const f = await file.getFile();
+    return URL.createObjectURL(f);
+}
+exports.getFileURL = getFileURL;
+// Releases a URL from getFileURL. blob: URLs leak until the document is gone unless revoked; https/file:
+// URLs need no cleanup, so this is a no-op for them.
+function disposeFileURL(url) {
+    if (url.startsWith("blob:")) {
+        try {
+            URL.revokeObjectURL(url);
+        }
+        catch ( /* not in a browser, or already revoked */_a) { /* not in a browser, or already revoked */ }
+    }
+}
+exports.disposeFileURL = disposeFileURL;
+// A StorageFactory backed by a remote server (path -> FileStorage), for code that injects its own
+// storage into BulkDatabase2 rather than going through the directory prompt.
+function getRemoteFileStorageFactory(url, password, options) {
+    const root = (0, remoteFileStorage_1.getRemoteDirectoryHandle)(url, password, options);
+    return async (pathStr) => {
+        let base = root;
+        for (const part of pathStr.replaceAll("\\", "/").split("/")) {
+            if (!part)
+                continue;
+            base = await base.getDirectoryHandle(part, { create: true });
+        }
+        return wrapHandle(base);
     };
 }
+exports.getRemoteFileStorageFactory = getRemoteFileStorageFactory;
 async function tryToLoadPointer(pointer) {
     let result = await (0, fileSystemPointer_1.getFileSystemPointer)({ pointer });
     if (!result)
@@ -341,5 +783,6 @@ async function tryToLoadPointer(pointer) {
         return;
     return handle;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"FileFolderAPI.js","sourceRoot":"","sources":["FileFolderAPI.tsx"],"names":[],"mappings":"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","sourcesContent":["import preact from \"preact\";\nimport { getFileSystemPointer, storeFileSystemPointer } from \"./fileSystemPointer\";\nimport { observable } from \"../misc/mobxTyped\";\nimport { observer } from \"../misc/observer\";\nimport { cache, lazy } from \"socket-function/src/caching\";\nimport { css, isNode } from \"typesafecss\";\nimport { IStorageRaw } from \"./IStorage\";\nimport { runInSerial } from \"socket-function/src/batching\";\nimport { getFileStorageIndexDB } from \"./IndexedDBFileFolderAPI\";\nimport fs from \"fs\";\nimport path from \"path\";\n\n// NOTE: IndexedDB is required for iOS, at least. We MIGHT want to make\n//  this a user supported toggle too, so they can choose during runtime if they want it.\n// DO NOT enable this is isNode\nconst USE_INDEXED_DB = false;\n\ntype FileWrapper = {\n    getFile(): Promise<{\n        size: number;\n        lastModified: number;\n        arrayBuffer(): Promise<ArrayBuffer>;\n    }>;\n    createWritable(config?: { keepExistingData?: boolean }): Promise<{\n        seek(offset: number): Promise<void>;\n        write(value: Buffer): Promise<void>;\n        close(): Promise<void>;\n    }>;\n};\ntype DirectoryWrapper = {\n    removeEntry(key: string, options?: { recursive?: boolean }): Promise<void>;\n    getFileHandle(key: string, options?: { create?: boolean }): Promise<FileWrapper>;\n    getDirectoryHandle(key: string, options?: { create?: boolean }): Promise<DirectoryWrapper>;\n    [Symbol.asyncIterator](): AsyncIterableIterator<[string, {\n        kind: \"file\";\n        name: string;\n        getFile(): Promise<FileWrapper>;\n    } | {\n        kind: \"directory\";\n        name: string;\n        getDirectoryHandle(key: string, options?: { create?: boolean }): Promise<DirectoryWrapper>;\n    }]>;\n};\n\nlet displayData = observable({\n    ui: undefined as undefined | preact.ComponentChildren,\n}, undefined, { deep: false });\n\nconst storageKey = \"syncFileSystemCamera3\";\n\n@observer\nclass DirectoryPrompter extends preact.Component {\n    render() {\n        if (!displayData.ui) return undefined;\n        return (\n            <div className={\n                css.position(\"fixed\").pos(0, 0).size(\"100vw\", \"100vh\")\n                    .zIndex(1)\n                    .background(\"white\")\n                    .center\n                    .fontSize(40)\n            }>\n                {displayData.ui}\n            </div>\n        );\n    }\n}\n\nclass NodeJSFileHandleWrapper implements FileWrapper {\n    constructor(private filePath: string) {\n    }\n\n    async getFile() {\n        const stats = await fs.promises.stat(this.filePath);\n        return {\n            size: stats.size,\n            lastModified: stats.mtimeMs,\n            arrayBuffer: async () => {\n                const buffer = await fs.promises.readFile(this.filePath);\n                return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);\n            }\n        };\n    }\n\n    async createWritable(config?: { keepExistingData?: boolean }) {\n        let fileHandle: fs.promises.FileHandle;\n        const flags = config?.keepExistingData ? \"r+\" : \"w\";\n\n        // Ensure the directory exists\n        await fs.promises.mkdir(path.dirname(this.filePath), { recursive: true });\n\n        // Open or create the file\n        if (config?.keepExistingData && await fs.promises.access(this.filePath).then(() => true).catch(() => false)) {\n            fileHandle = await fs.promises.open(this.filePath, flags);\n        } else {\n            fileHandle = await fs.promises.open(this.filePath, \"w\");\n        }\n\n        let position = 0;\n\n        return {\n            seek: async (offset: number) => {\n                position = offset;\n            },\n            write: async (value: Buffer) => {\n                await fileHandle.write(value, 0, value.length, position);\n                position += value.length;\n            },\n            close: async () => {\n                await fileHandle.close();\n            }\n        };\n    }\n}\n\nclass NodeJSDirectoryHandleWrapper implements DirectoryWrapper {\n    constructor(private rootPath: string) {\n    }\n\n    async removeEntry(key: string, options?: { recursive?: boolean }) {\n        const entryPath = path.join(this.rootPath, key);\n        if (options?.recursive) {\n            await fs.promises.rm(entryPath, { recursive: true, force: true });\n        } else {\n            await fs.promises.unlink(entryPath);\n        }\n    }\n\n    async getFileHandle(key: string, options?: { create?: boolean }): Promise<FileWrapper> {\n        const filePath = path.join(this.rootPath, key);\n\n        const exists = await fs.promises.access(filePath).then(() => true).catch(() => false);\n\n        if (!exists && options?.create) {\n            // Ensure the directory exists\n            await fs.promises.mkdir(path.dirname(filePath), { recursive: true });\n            // Create the file\n            await fs.promises.writeFile(filePath, Buffer.alloc(0));\n        } else if (!exists) {\n            throw new Error(`File not found: ${filePath}`);\n        }\n\n        return new NodeJSFileHandleWrapper(filePath);\n    }\n\n    async getDirectoryHandle(key: string, options?: { create?: boolean }): Promise<DirectoryWrapper> {\n        const dirPath = path.join(this.rootPath, key);\n\n        if (options?.create) {\n            await fs.promises.mkdir(dirPath, { recursive: true });\n        } else {\n            const exists = await fs.promises.access(dirPath).then(() => true).catch(() => false);\n            if (!exists) {\n                throw new Error(`Directory not found: ${dirPath}`);\n            }\n        }\n\n        return new NodeJSDirectoryHandleWrapper(dirPath);\n    }\n\n    async *[Symbol.asyncIterator](): AsyncIterableIterator<[string, {\n        kind: \"file\";\n        name: string;\n        getFile(): Promise<FileWrapper>;\n    } | {\n        kind: \"directory\";\n        name: string;\n        getDirectoryHandle(key: string, options?: { create?: boolean }): Promise<DirectoryWrapper>;\n    }]> {\n        // Ensure directory exists\n        await fs.promises.mkdir(this.rootPath, { recursive: true });\n\n        const entries = await fs.promises.readdir(this.rootPath, { withFileTypes: true });\n\n        for (const entry of entries) {\n            if (entry.isFile()) {\n                yield [entry.name, {\n                    kind: \"file\",\n                    name: entry.name,\n                    getFile: async () => new NodeJSFileHandleWrapper(path.join(this.rootPath, entry.name))\n                }];\n            } else if (entry.isDirectory()) {\n                const dirPath = path.join(this.rootPath, entry.name);\n                yield [entry.name, {\n                    kind: \"directory\",\n                    name: entry.name,\n                    getDirectoryHandle: async (key: string, options?: { create?: boolean }) => {\n                        return new NodeJSDirectoryHandleWrapper(dirPath).getDirectoryHandle(key, options);\n                    }\n                }];\n            }\n        }\n    }\n}\n\n\n// NOTE: Blocks until the user provides a directory\nexport const getDirectoryHandle = lazy(async function getDirectoryHandle(): Promise<DirectoryWrapper> {\n    if (isNode()) {\n        return new NodeJSDirectoryHandleWrapper(path.resolve(\"./data/\"));\n    }\n    let root = document.createElement(\"div\");\n    document.body.appendChild(root);\n    preact.render(<DirectoryPrompter />, root);\n    try {\n\n        let handle: DirectoryWrapper | undefined;\n\n        let storedId = localStorage.getItem(storageKey);\n        if (storedId) {\n            let doneLoad = false;\n            setTimeout(() => {\n                if (doneLoad) return;\n                console.log(\"Waiting for user to click\");\n                displayData.ui = \"Click anywhere to allow file system access\";\n            }, 500);\n            try {\n                handle = await tryToLoadPointer(storedId);\n            } catch { }\n            doneLoad = true;\n            if (handle) {\n                return handle;\n            }\n        }\n        let fileCallback: (handle: DirectoryWrapper) => void;\n        let promise = new Promise<DirectoryWrapper>(resolve => {\n            fileCallback = resolve;\n        });\n        displayData.ui = (\n            <button\n                className={css.fontSize(40).pad2(80, 40)}\n                onClick={async () => {\n                    console.log(\"Waiting for user to give permission\");\n                    const handle = await window.showDirectoryPicker();\n                    await handle.requestPermission({ mode: \"readwrite\" });\n                    let storedId = await storeFileSystemPointer({ mode: \"readwrite\", handle });\n                    localStorage.setItem(storageKey, storedId);\n                    fileCallback(handle as any);\n                }}\n            >\n                Pick Media Directory\n            </button>\n        );\n        return await promise;\n    } finally {\n        preact.render(null, root);\n        root.remove();\n    }\n});\n\nexport const getFileStorageNested = cache(async function getFileStorage(path: string): Promise<FileStorage> {\n    let base = await getDirectoryHandle();\n    for (let part of path.split(\"/\")) {\n        if (!part) continue;\n        base = await base.getDirectoryHandle(part, { create: true });\n    }\n    return wrapHandle(base);\n});\nexport const getFileStorage = lazy(async function getFileStorage(): Promise<FileStorage> {\n    if (USE_INDEXED_DB) {\n        return await getFileStorageIndexDB();\n    }\n\n    let handle = await getDirectoryHandle();\n    return wrapHandle(handle);\n});\nexport function resetStorageLocation() {\n    localStorage.removeItem(storageKey);\n    window.location.reload();\n}\n\nexport type NestedFileStorage = {\n    hasKey(key: string): Promise<boolean>;\n    getStorage(key: string): Promise<FileStorage>;\n    removeStorage(key: string): Promise<void>;\n    getKeys(): Promise<string[]>;\n};\n\nexport type FileStorage = IStorageRaw & {\n    folder: NestedFileStorage;\n};\n\nlet appendQueue = cache((key: string) => {\n    return runInSerial((fnc: () => Promise<void>) => fnc());\n});\n\n\nasync function fixedGetFileHandle(config: {\n    handle: DirectoryWrapper;\n    key: string;\n    create: true;\n}): Promise<FileWrapper>;\nasync function fixedGetFileHandle(config: {\n    handle: DirectoryWrapper;\n    key: string;\n    create?: boolean;\n}): Promise<FileWrapper | undefined>;\nasync function fixedGetFileHandle(config: {\n    handle: DirectoryWrapper;\n    key: string;\n    create?: boolean;\n}): Promise<FileWrapper | undefined> {\n    if (config.key.includes(\"/\")) {\n        throw new Error(`Cannot use folders directly in file system read / writes. Use a wrapper which handles the folder navigation. Path was ${JSON.stringify(config.key)}`);\n    }\n    // ALWAYS try without create, because the sshfs-win sucks and doesn't support `create: true`? Wtf...\n    try {\n        return await config.handle.getFileHandle(config.key);\n    } catch {\n        if (!config.create) return undefined;\n    }\n    return await config.handle.getFileHandle(config.key, { create: true });\n}\n\nfunction wrapHandleFiles(handle: DirectoryWrapper): IStorageRaw {\n    return {\n        async getInfo(key: string) {\n            try {\n                const file = await handle.getFileHandle(key);\n                const fileContent = await file.getFile();\n                return {\n                    size: fileContent.size,\n                    lastModified: fileContent.lastModified,\n                };\n            } catch (error) {\n                return undefined;\n            }\n        },\n        async get(key: string): Promise<Buffer | undefined> {\n            try {\n                const file = await handle.getFileHandle(key);\n                const fileContent = await file.getFile();\n                const arrayBuffer = await fileContent.arrayBuffer();\n                return Buffer.from(arrayBuffer);\n            } catch (error) {\n                return undefined;\n            }\n        },\n\n        async append(key: string, value: Buffer): Promise<void> {\n            await appendQueue(key)(async () => {\n                // NOTE: Interesting point. Chrome doesn't optimize this to be an append, and instead\n                //  rewrites the entire file.\n                const file = await fixedGetFileHandle({ handle, key, create: true });\n                const writable = await file.createWritable({ keepExistingData: true });\n                let offset = (await file.getFile()).size;\n                await writable.seek(offset);\n                await writable.write(value);\n                await writable.close();\n            });\n        },\n\n        async set(key: string, value: Buffer): Promise<void> {\n            const file = await fixedGetFileHandle({ handle, key, create: true });\n            const writable = await file.createWritable();\n            await writable.write(value);\n            await writable.close();\n        },\n\n        async remove(key: string): Promise<void> {\n            await handle.removeEntry(key);\n        },\n\n        async getKeys(): Promise<string[]> {\n            const keys: string[] = [];\n            for await (const [name, entry] of handle) {\n                if (entry.kind === \"file\") {\n                    keys.push(entry.name);\n                }\n            }\n            return keys;\n        },\n\n        async reset() {\n            for await (const [name, entry] of handle) {\n                await handle.removeEntry(entry.name, { recursive: true });\n            }\n        },\n    };\n}\n\nfunction wrapHandleNested(handle: DirectoryWrapper): NestedFileStorage {\n    return {\n        async hasKey(key: string): Promise<boolean> {\n            try {\n                await handle.getDirectoryHandle(key);\n                return true;\n            } catch (error) {\n                return false;\n            }\n        },\n\n        async getStorage(key: string): Promise<FileStorage> {\n            const subDirectory = await handle.getDirectoryHandle(key, { create: true });\n            return wrapHandle(subDirectory);\n        },\n\n        async removeStorage(key: string): Promise<void> {\n            await handle.removeEntry(key, { recursive: true });\n        },\n\n        async getKeys(): Promise<string[]> {\n            const keys: string[] = [];\n            for await (const [name, entry] of handle) {\n                if (entry.kind === \"directory\") {\n                    keys.push(entry.name);\n                }\n            }\n            return keys;\n        },\n    };\n}\n\nfunction wrapHandle(handle: DirectoryWrapper): FileStorage {\n    return {\n        ...wrapHandleFiles(handle),\n        folder: wrapHandleNested(handle),\n    };\n}\n\nasync function tryToLoadPointer(pointer: string) {\n    let result = await getFileSystemPointer({ pointer });\n    if (!result) return;\n    let handle = await result?.onUserActivation();\n    if (!handle) return;\n    return handle as any as DirectoryWrapper;\n}"]}
- /* _JS_SOURCE_HASH = "2c171fd06df7fe1cfb75e04ee9f78c65385c23788b53f9fe0775b27670622e69"; */
+exports.tryToLoadPointer = tryToLoadPointer;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"FileFolderAPI.js","sourceRoot":"","sources":["FileFolderAPI.tsx"],"names":[],"mappings":"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","sourcesContent":["import preact from \"preact\";\nimport { findGrantedPointerHandle, getFileSystemPointer, storeFileSystemPointer } from \"./fileSystemPointer\";\nimport { observable } from \"mobx\";\nimport { observer } from \"../render-utils/observer\";\nimport { cache, lazy } from \"socket-function/src/caching\";\nimport { css, isNode } from \"typesafecss\";\nimport { IStorageRaw } from \"./IStorage\";\nimport { runInSerial } from \"socket-function/src/batching\";\nimport { getFileStorageIndexDB } from \"./IndexedDBFileFolderAPI\";\nimport { getRemoteDirectoryHandle, testRemoteConnection, RemoteOptions } from \"./remoteFileStorage\";\nimport fs from \"fs\";\nimport path from \"path\";\n\ndeclare global {\n    interface Window {\n        showSaveFilePicker(config?: {\n            types: {\n                description: string; accept: { [mimeType: string]: string[] }\n            }[];\n        }): Promise<FileSystemFileHandle>;\n        showDirectoryPicker(): Promise<FileSystemDirectoryHandle>;\n        showOpenFilePicker(config?: {\n            types: {\n                description: string; accept: { [mimeType: string]: string[] }\n            }[];\n        }): Promise<FileSystemFileHandle[]>;\n    }\n    interface FileSystemDirectoryHandle {\n        requestPermission(config?: { mode: \"read\" | \"readwrite\" }): Promise<PermissionState>;\n    }\n}\n\n\n// NOTE: IndexedDB is required for iOS, at least. We MIGHT want to make\n//  this a user supported toggle too, so they can choose during runtime if they want it.\n// DO NOT enable this is isNode\nconst USE_INDEXED_DB = false;\n\n// How often a worker rechecks the pointer IndexedDB for a granted handle when none is available yet.\nconst WORKER_POLL_INTERVAL_MS = 60 * 1000;\n\n// These mirror the subset of the native FileSystemFileHandle / FileSystemDirectoryHandle API we use, so\n// the native browser handles, the Node handles, and the remote handles are all interchangeable — and\n// code written against the native handle (e.g. a recursive walk over `handle.entries()`) works on any of\n// them. kind/name and entries() are part of that contract.\nexport type FileWrapper = {\n    readonly kind: \"file\";\n    readonly name: string;\n    getFile(): Promise<{\n        size: number;\n        lastModified: number;\n        arrayBuffer(): Promise<ArrayBuffer>;\n        // Matches Blob.slice (which the native File object provides), so the browser\n        //  implementation works vanilla. End is exclusive, both clamped to the file size.\n        slice(start: number, end: number): { arrayBuffer(): Promise<ArrayBuffer> };\n    }>;\n    createWritable(config?: { keepExistingData?: boolean }): Promise<{\n        seek(offset: number): Promise<void>;\n        write(value: Buffer): Promise<void>;\n        close(): Promise<void>;\n    }>;\n    // Returns a URL for the file's bytes, usable in <video>/<img>/fetch. Optional — the native browser\n    // FileSystemFileHandle has no such method, so prefer the getFileURL() helper, which falls back to a\n    // blob: URL via createObjectURL for native handles. Always release it with disposeFileURL when done.\n    getURL?(): Promise<string>;\n};\nexport type DirectoryWrapper = {\n    readonly kind: \"directory\";\n    readonly name: string;\n    // Full path from the storage root, for diagnostics/logging (the native handle doesn't expose paths,\n    // so it's optional). e.g. \"bulkDatabases2/myCollection\".\n    readonly fullPath?: string;\n    // True when this storage is served over the network (a remote server) rather than a local disk, so\n    // callers can adapt for the higher latency/cost (local/native handles leave it undefined = false).\n    readonly isRemote?: boolean;\n    removeEntry(key: string, options?: { recursive?: boolean }): Promise<void>;\n    getFileHandle(key: string, options?: { create?: boolean }): Promise<FileWrapper>;\n    getDirectoryHandle(key: string, options?: { create?: boolean }): Promise<DirectoryWrapper>;\n    // Each entry IS a handle (file or directory), so a recursive walk keeps working at every level.\n    entries(): AsyncIterableIterator<[string, FileWrapper | DirectoryWrapper]>;\n    [Symbol.asyncIterator](): AsyncIterableIterator<[string, FileWrapper | DirectoryWrapper]>;\n};\n\nlet displayData = observable({\n    ui: undefined as undefined | preact.ComponentChildren,\n}, undefined, { deep: false });\n\nlet fileAPIKey = \"\";\nfunction getFileAPIKey() {\n    if (!fileAPIKey) throw new Error(\"Must call setFileAPIKey before using file system. Just pass any key. This prevents reusing the file system api that other development apps might be using.\");\n    return fileAPIKey;\n}\nexport function setFileAPIKey(key: string) {\n    fileAPIKey = key;\n}\n\n// A directory handle to serve as the storage root instead of resolving one via\n// the picker / stored-pointer / remote flow. Set this in a context that can't run\n// the interactive resolution — most importantly a Web Worker, which has no DOM to\n// prompt with and no localStorage pointer. The owning window resolves the handle\n// (with its permission grant) and postMessages it in; the worker calls this before\n// touching any storage. When set, getDirectoryHandle returns it directly and skips\n// every DOM / localStorage branch below.\nlet storageRootOverride: FileSystemDirectoryHandle | undefined;\nexport function setStorageRootOverride(handle: FileSystemDirectoryHandle | undefined): void {\n    storageRootOverride = handle;\n}\n\n// ---- remote (server) storage config ----\n// Instead of a local folder, the user can point at a remoteFileServer.js instance (URL + password).\n// When configured, getFileStorageNested2 serves everything from that server. Persisted in localStorage.\ntype RemoteConfig = { url: string; password: string };\nfunction remoteConfigKey() { return getFileAPIKey() + \":remote\"; }\nfunction loadRemoteConfig(): RemoteConfig | undefined {\n    try {\n        const s = localStorage.getItem(remoteConfigKey());\n        if (!s) return undefined;\n        const c = JSON.parse(s);\n        if (c && typeof c.url === \"string\" && typeof c.password === \"string\") return c;\n    } catch { /* ignore */ }\n    return undefined;\n}\nfunction saveRemoteConfig(c: RemoteConfig) { localStorage.setItem(remoteConfigKey(), JSON.stringify(c)); }\n\n// The server is always HTTPS on the filehoster's default port, so the user only needs to type the host\n// (e.g. \"65.109.93.113\"). We strip any scheme/path they include and default the port if omitted.\nconst DEFAULT_REMOTE_PORT = 8787; // matches remoteFileServer.js's default\nfunction normalizeServerUrl(raw: string): string {\n    let s = raw.trim().replace(/^\\w+:\\/\\//, \"\").replace(/\\/.*$/, \"\");\n    if (!s) return \"\";\n    if (!/:\\d+$/.test(s)) s += \":\" + DEFAULT_REMOTE_PORT;\n    return \"https://\" + s;\n}\n\n// One shared remote DirectoryWrapper (and therefore one shared range cache) per remote config.\nlet remoteHandle: { key: string; handle: DirectoryWrapper } | undefined;\nfunction getRemoteHandle(remote: RemoteConfig): DirectoryWrapper {\n    const key = remote.url + \"\\0\" + remote.password;\n    if (!remoteHandle || remoteHandle.key !== key) {\n        remoteHandle = { key, handle: getRemoteDirectoryHandle(remote.url, remote.password) };\n    }\n    return remoteHandle.handle;\n}\n\n@observer\nclass DirectoryPrompter extends preact.Component {\n    render() {\n        if (!displayData.ui) return undefined;\n        return (\n            <div className={\n                css.position(\"fixed\").pos(0, 0).size(\"100vw\", \"100vh\")\n                    .zIndex(2147483647)\n                    .background(\"white\")\n                    .center\n                    .fontSize(40)\n            }>\n                {displayData.ui}\n            </div>\n        );\n    }\n}\n\n// \"Connect to a server\" option for the directory prompt: collapses to a button, expands to address +\n// password fields. On connect it ACTUALLY connects (testRemoteConnection); only on success does it\n// persist the config and call onConnected, so the caller (getDirectoryHandle) resolves with a working\n// remote handle. Failures are shown to the user (and logged, without the password), never swallowed.\n// `initial` pre-fills + expands the form (used to retry a remembered server that stopped working).\n@observer\nclass ServerConnectForm extends preact.Component<{ onConnected: (config: RemoteConfig) => void; initial?: RemoteConfig }> {\n    private obs = observable({\n        expanded: !!this.props.initial,\n        url: this.props.initial?.url || \"\",\n        password: this.props.initial?.password || \"\",\n        error: \"\", connecting: false, needsCert: false, showPassword: false,\n    });\n    private cleanUrl() { return normalizeServerUrl(this.obs.url); }\n    private connect = async () => {\n        const s = this.obs;\n        s.error = \"\";\n        s.needsCert = false;\n        s.connecting = true;\n        try {\n            const url = this.cleanUrl();\n            if (!url) { s.error = \"Enter a server address.\"; return; }\n            const result = await testRemoteConnection(url, s.password.trim());\n            if (result.status === \"ok\") {\n                const config: RemoteConfig = { url, password: s.password.trim() };\n                saveRemoteConfig(config);             // remember for next session\n                this.props.onConnected(config);       // hand the verified server back to getDirectoryHandle\n                return;\n            }\n            if (result.status === \"unauthorized\") {\n                s.error = \"The server rejected that password.\";\n                console.error(\"Remote connect: unauthorized for\", url);\n            } else {\n                // Got nothing back — usually the self-signed certificate isn't trusted yet, but show the\n                // actual error too so a wrong address / down server / CORS issue is diagnosable.\n                s.needsCert = true;\n                s.error = \"Couldn't reach the server: \" + result.error;\n                console.error(\"Remote connect: unreachable\", url, \"-\", result.error);\n            }\n        } catch (e) {\n            s.error = \"Connection error: \" + ((e as Error).message || String(e));\n            console.error(\"Remote connect threw:\", e);\n        } finally {\n            s.connecting = false;\n        }\n    };\n    render() {\n        const s = this.obs;\n        const inputCss = css.fontSize(28).pad2(24, 14).width(560).maxWidth(\"80vw\");\n        const btnCss = css.fontSize(32).pad2(60, 30);\n        if (!s.expanded) {\n            return <button className={btnCss} onClick={() => s.expanded = true}>Connect to a server</button>;\n        }\n        return (\n            <div className={css.vbox(16).center}>\n                <input className={inputCss} placeholder=\"server address (e.g. 65.109.93.113, or host:port)\" value={s.url}\n                    onInput={e => s.url = (e.target as HTMLInputElement).value} />\n                <div className={css.hbox(10).center}>\n                    <input className={inputCss} type={s.showPassword ? \"text\" : \"password\"} placeholder=\"password (six words)\" value={s.password}\n                        onInput={e => s.password = (e.target as HTMLInputElement).value} />\n                    <button className={css.fontSize(22).pad2(24, 12)} onClick={() => s.showPassword = !s.showPassword}>\n                        {s.showPassword ? \"Hide\" : \"Show\"}\n                    </button>\n                </div>\n                {s.error ? <div className={css.fontSize(22).color(\"red\").maxWidth(\"80vw\")}>{s.error}</div> : null}\n                {s.needsCert ? (\n                    <div className={css.vbox(10).center.fontSize(20).maxWidth(620).maxWidth(\"80vw\").textAlign(\"center\").color(\"hsl(0, 0%, 25%)\")}>\n                        <div>This server uses a self-signed certificate, so your browser has to trust it once:</div>\n                        <div>1. Open the server in a new tab (button below). &nbsp; 2. Accept the security warning (Advanced → Proceed). &nbsp; 3. Come back and click Retry.</div>\n                        <button className={css.fontSize(26).pad2(40, 20)}\n                            onClick={() => { const u = this.cleanUrl(); if (u) window.open(u + \"/\", \"_blank\"); }}>\n                            Open server &amp; accept certificate\n                        </button>\n                    </div>\n                ) : null}\n                <div className={css.hbox(16)}>\n                    <button className={btnCss} disabled={s.connecting} onClick={this.connect}>\n                        {s.connecting ? \"Connecting…\" : s.needsCert ? \"Retry\" : \"Connect\"}\n                    </button>\n                    <button className={btnCss} onClick={() => { s.expanded = false; s.error = \"\"; s.needsCert = false; }}>Back</button>\n                </div>\n            </div>\n        );\n    }\n}\n\nexport class NodeJSFileHandleWrapper implements FileWrapper {\n    constructor(private filePath: string) {\n    }\n    readonly kind = \"file\" as const;\n    get name() { return path.basename(this.filePath); }\n\n    async getFile() {\n        const stats = await fs.promises.stat(this.filePath);\n        const filePath = this.filePath;\n        return {\n            size: stats.size,\n            lastModified: stats.mtimeMs,\n            arrayBuffer: async () => {\n                const buffer = await fs.promises.readFile(filePath);\n                return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);\n            },\n            slice: (start: number, end: number) => ({\n                arrayBuffer: async () => {\n                    const clampedStart = Math.min(Math.max(start, 0), stats.size);\n                    const clampedEnd = Math.min(Math.max(end, clampedStart), stats.size);\n                    const length = clampedEnd - clampedStart;\n                    const fileHandle = await fs.promises.open(filePath, \"r\");\n                    try {\n                        const buffer = Buffer.alloc(length);\n                        await fileHandle.read(buffer, 0, length, clampedStart);\n                        return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);\n                    } finally {\n                        await fileHandle.close();\n                    }\n                }\n            })\n        };\n    }\n\n    async getURL() {\n        return \"file://\" + path.resolve(this.filePath);\n    }\n\n    async createWritable(config?: { keepExistingData?: boolean }) {\n        let fileHandle: fs.promises.FileHandle;\n        const flags = config?.keepExistingData ? \"r+\" : \"w\";\n\n        // Ensure the directory exists\n        await fs.promises.mkdir(path.dirname(this.filePath), { recursive: true });\n\n        // Open or create the file\n        if (config?.keepExistingData && await fs.promises.access(this.filePath).then(() => true).catch(() => false)) {\n            fileHandle = await fs.promises.open(this.filePath, flags);\n        } else {\n            fileHandle = await fs.promises.open(this.filePath, \"w\");\n        }\n\n        let position = 0;\n\n        return {\n            seek: async (offset: number) => {\n                position = offset;\n            },\n            write: async (value: Buffer) => {\n                await fileHandle.write(value, 0, value.length, position);\n                position += value.length;\n            },\n            close: async () => {\n                await fileHandle.close();\n            }\n        };\n    }\n}\n\nexport class NodeJSDirectoryHandleWrapper implements DirectoryWrapper {\n    constructor(private rootPath: string) {\n    }\n    readonly kind = \"directory\" as const;\n    get name() { return path.basename(this.rootPath); }\n    get fullPath() { return this.rootPath; }\n    entries() { return this[Symbol.asyncIterator](); }\n\n    async removeEntry(key: string, options?: { recursive?: boolean }) {\n        const entryPath = path.join(this.rootPath, key);\n        if (options?.recursive) {\n            await fs.promises.rm(entryPath, { recursive: true, force: true });\n        } else {\n            await fs.promises.unlink(entryPath);\n        }\n    }\n\n    async getFileHandle(key: string, options?: { create?: boolean }): Promise<FileWrapper> {\n        const filePath = path.join(this.rootPath, key);\n\n        const exists = await fs.promises.access(filePath).then(() => true).catch(() => false);\n\n        if (!exists && options?.create) {\n            // Ensure the directory exists\n            await fs.promises.mkdir(path.dirname(filePath), { recursive: true });\n            // Create the file\n            await fs.promises.writeFile(filePath, Buffer.alloc(0));\n        } else if (!exists) {\n            // Tag as ENOENT so readWithRetry treats it as a genuinely-missing file (return undefined now)\n            // rather than a transient read failure to retry 6× with backoff — missing files are normal\n            // (a concurrent merge deletes a file mid-read), and retrying them is catastrophically slow.\n            const err = new Error(`File not found: ${filePath}`) as Error & { code?: string };\n            err.code = \"ENOENT\";\n            throw err;\n        }\n\n        return new NodeJSFileHandleWrapper(filePath);\n    }\n\n    async getDirectoryHandle(key: string, options?: { create?: boolean }): Promise<DirectoryWrapper> {\n        const dirPath = path.join(this.rootPath, key);\n\n        if (options?.create) {\n            await fs.promises.mkdir(dirPath, { recursive: true });\n        } else {\n            const exists = await fs.promises.access(dirPath).then(() => true).catch(() => false);\n            if (!exists) {\n                throw new Error(`Directory not found: ${dirPath}`);\n            }\n        }\n\n        return new NodeJSDirectoryHandleWrapper(dirPath);\n    }\n\n    async *[Symbol.asyncIterator](): AsyncIterableIterator<[string, FileWrapper | DirectoryWrapper]> {\n        // Ensure directory exists\n        await fs.promises.mkdir(this.rootPath, { recursive: true });\n\n        const entries = await fs.promises.readdir(this.rootPath, { withFileTypes: true });\n\n        for (const entry of entries) {\n            const childPath = path.join(this.rootPath, entry.name);\n            if (entry.isFile()) {\n                yield [entry.name, new NodeJSFileHandleWrapper(childPath)];\n            } else if (entry.isDirectory()) {\n                yield [entry.name, new NodeJSDirectoryHandleWrapper(childPath)];\n            }\n        }\n    }\n}\n\n\n// When set, getDirectoryHandle skips every prompt + remote check and serves from the browser's Origin\n// Private File System (OPFS). One named subfolder is \"current\" per fileAPIKey; pickPrivateFolder /\n// resetStorageLocation switch which one. Set this in app startup BEFORE the first getDirectoryHandle.\nlet opfsEnabled = false;\nconst OPFS_FOLDERS_DIR = \"folders\";\nconst OPFS_DEFAULT_FOLDER = \"default\";\nfunction opfsCurrentKey() { return getFileAPIKey() + \":opfs:current\"; }\nfunction getCurrentOpfsFolder(): string {\n    return localStorage.getItem(opfsCurrentKey()) || OPFS_DEFAULT_FOLDER;\n}\nfunction setCurrentOpfsFolder(name: string): void {\n    localStorage.setItem(opfsCurrentKey(), name);\n}\n\n// Switches getDirectoryHandle to the Origin Private File System. No directory picker, no permission\n// prompt, no remote server check. Persists nothing — call on every app start before reading storage.\nexport function usePrivateFileSystem(): void {\n    opfsEnabled = true;\n}\n\n// Whether the OPFS branch is in effect (so other callers can adapt — e.g. skip the \"find data subdir\"\n// hack in getFileStorageNested2 since OPFS is always a clean root we own end-to-end).\nexport function isPrivateFileSystemActive(): boolean {\n    return opfsEnabled;\n}\n\nasync function getOpfsFoldersDir(): Promise<FileSystemDirectoryHandle> {\n    if (!navigator.storage?.getDirectory) {\n        throw new Error(\"Private File System Access API not supported in this browser\");\n    }\n    if (location.protocol === \"file:\") {\n        throw new Error(\"Private File System API is disallowed in file:// locations. Host on an actual origin.\");\n    }\n    const root = await navigator.storage.getDirectory();\n    const keyed = await root.getDirectoryHandle(getFileAPIKey(), { create: true });\n    return await keyed.getDirectoryHandle(OPFS_FOLDERS_DIR, { create: true });\n}\n\nasync function getCurrentOpfsHandle(): Promise<DirectoryWrapper> {\n    const folders = await getOpfsFoldersDir();\n    const folder = await folders.getDirectoryHandle(getCurrentOpfsFolder(), { create: true });\n    return folder as unknown as DirectoryWrapper;\n}\n\n// All previously-used OPFS subfolders under this fileAPIKey, sorted alphabetically (timestamp-named\n// auto-generated folders therefore sort chronologically). Use this to surface a list, then call\n// pickPrivateFolder(name) to switch.\nexport async function listPrivateFolders(): Promise<string[]> {\n    if (!navigator.storage?.getDirectory) return [];\n    let folders: FileSystemDirectoryHandle;\n    try { folders = await getOpfsFoldersDir(); } catch { return []; }\n    const names: string[] = [];\n    for await (const [name, handle] of (folders as unknown as AsyncIterable<[string, { kind: string }]>)) {\n        if (handle.kind === \"directory\") names.push(name);\n    }\n    return names.sort();\n}\n\n// Switch to a specific OPFS subfolder and reload so getDirectoryHandle re-resolves to it. The folder\n// is created if it doesn't exist yet.\nexport function pickPrivateFolder(name: string): void {\n    setCurrentOpfsFolder(name);\n    window.location.reload();\n}\n\n// Returns the directory handle to use — local (Node / picked folder) OR a remote server, both as the\n// same DirectoryWrapper, so callers don't know or care which it is. A remembered server is VERIFIED\n// (we actually connect) before use; if it no longer works we re-prompt, just like a local folder whose\n// permission was lost. Blocks until ready (or the user dismisses, which rejects).\nexport const getDirectoryHandle = lazy(async function getDirectoryHandle(): Promise<DirectoryWrapper> {\n    // An injected root (e.g. a Web Worker handed the handle by its owning window)\n    // short-circuits the whole interactive resolution — no picker, no DOM, no\n    // localStorage. Must come first so a worker never reaches the branches below.\n    if (storageRootOverride) {\n        return storageRootOverride as unknown as DirectoryWrapper;\n    }\n    // A worker can't show the picker (no DOM / no user activation) and can't read localStorage, but\n    // it CAN open the pointer IndexedDB the main-thread picker persists to. Poll it for a handle\n    // whose permission is already granted; the owning window may also postMessage a handle in\n    // mid-poll (checked each iteration). This has to come before the isNode branch: typesafecss's\n    // isNode() returns true in workers (window is undefined), so a worker would otherwise fall into\n    // the Node branch and try to use fs/path.\n    if (\"WorkerGlobalScope\" in globalThis) {\n        while (true) {\n            if (storageRootOverride) return storageRootOverride as unknown as DirectoryWrapper;\n            let handle = await findGrantedPointerHandle(\"readwrite\");\n            if (handle) return handle as unknown as DirectoryWrapper;\n            await new Promise(resolve => setTimeout(resolve, WORKER_POLL_INTERVAL_MS));\n        }\n    }\n    if (isNode()) {\n        return new NodeJSDirectoryHandleWrapper(path.resolve(\"./data/\"));\n    }\n    if (opfsEnabled) {\n        return getCurrentOpfsHandle();\n    }\n\n    // A server connected in a previous session: only reuse it if it still actually works.\n    const savedRemote = loadRemoteConfig();\n    if (savedRemote) {\n        const result = await testRemoteConnection(savedRemote.url, savedRemote.password);\n        if (result.status === \"ok\") return getRemoteHandle(savedRemote);\n        console.warn(`Saved remote server didn't connect (${result.status})${result.status === \"unreachable\" ? \": \" + result.error : \"\"} — re-prompting.`);\n    }\n\n    let root = document.createElement(\"div\");\n    document.body.appendChild(root);\n    preact.render(<DirectoryPrompter />, root);\n    try {\n        let resolveHandle!: (h: DirectoryWrapper) => void;\n        let rejectHandle!: (e: Error) => void;\n        const promise = new Promise<DirectoryWrapper>((res, rej) => { resolveHandle = res; rejectHandle = rej; });\n\n        const pickLocal = async () => {\n            try {\n                const handle = await window.showDirectoryPicker();\n                await handle.requestPermission({ mode: \"readwrite\" });\n                const storedId = await storeFileSystemPointer({ mode: \"readwrite\", handle });\n                localStorage.setItem(getFileAPIKey(), storedId);\n                resolveHandle(handle as any);\n            } catch (e) {\n                console.error(\"Directory pick failed/cancelled:\", e); // stay on the prompt\n            }\n        };\n        const onConnected = (config: RemoteConfig) => { saveRemoteConfig(config); resolveHandle(getRemoteHandle(config)); };\n        // The three options, rendered fresh each time. If a saved server just failed, pre-fill + expand\n        // the connect form so the user can retry or fix it.\n        const renderOptions = () => (\n            <>\n                <button className={css.fontSize(40).pad2(80, 40)} onClick={pickLocal}>Pick Data Directory</button>\n                <ServerConnectForm onConnected={onConnected} initial={savedRemote} />\n                <button className={css.fontSize(40).pad2(80, 40)}\n                    onClick={() => rejectHandle(new Error(\"User dismissed file system access prompt\"))}>Dismiss</button>\n            </>\n        );\n\n        // A previously-picked local folder: try to restore it (may need a click). Skipped when a saved\n        // server failed — that user wants the server, so go straight to the (pre-filled) prompt.\n        const storedId = !savedRemote && localStorage.getItem(getFileAPIKey());\n        if (storedId) {\n            let doneLoad = false;\n            setTimeout(() => { if (!doneLoad) displayData.ui = \"Click anywhere to allow file system access\"; }, 500);\n            try {\n                const handle = await tryToLoadPointer(storedId);\n                doneLoad = true;\n                if (handle) return handle;\n            } catch (e) {\n                doneLoad = true;\n                console.error(e);\n                const msg = e instanceof Error ? e.message : String(e);\n                if (msg.includes(\"user activation\") || msg.includes(\"User activation\")) {\n                    displayData.ui = (\n                        <div className={css.vbox(20).center}>\n                            <button className={css.fontSize(40).pad2(80, 40)} onClick={async () => {\n                                displayData.ui = \"Loading...\";\n                                try {\n                                    const h = await tryToLoadPointer(storedId);\n                                    if (h) { resolveHandle(h); return; }\n                                } catch (retryError) { console.error(\"Retry failed:\", retryError); }\n                                displayData.ui = <div className={css.vbox(20).center}>{renderOptions()}</div>;\n                            }}>Click to restore file system access</button>\n                            {renderOptions()}\n                        </div>\n                    );\n                    return await promise;\n                }\n            }\n        }\n        displayData.ui = <div className={css.vbox(20).center}>{renderOptions()}</div>;\n        return await promise;\n    } finally {\n        preact.render(null, root);\n        root.remove();\n    }\n});\n\nexport const getFileStorageNested = cache(async function getFileStorage(path: string): Promise<FileStorage> {\n    let base = await getDirectoryHandle();\n    for (let part of path.split(\"/\")) {\n        if (!part) continue;\n        base = await base.getDirectoryHandle(part, { create: true });\n    }\n    return wrapHandle(base);\n});\n// Supports if the user selects the folder that contains the data folder or the data folder directly. If pathStr is an absolute path (and we're in nodejs) we use it directly.\nexport const getFileStorageNested2 = cache(async function getFileStorage(pathStr: string): Promise<FileStorage> {\n    let base: DirectoryWrapper;\n    pathStr = pathStr.replaceAll(\"\\\\\", \"/\");\n    if (isNode()) {\n        if (path.isAbsolute(pathStr)) {\n            return wrapHandle(new NodeJSDirectoryHandleWrapper(pathStr));\n        }\n        base = new NodeJSDirectoryHandleWrapper(path.resolve(\"./data/\"));\n    } else {\n        base = await getDirectoryHandle();\n        // Skip the \"find data subdir\" hack under OPFS — that's for picked directories where the user\n        // might have selected a folder with unrelated files; OPFS is a clean root we own end-to-end.\n        if (!opfsEnabled) {\n            let dirs: string[] = [];\n            let alls: string[] = [];\n            for await (const [name, entry] of base) {\n                if (entry.kind === \"directory\") {\n                    dirs.push(name);\n                }\n                alls.push(name);\n            }\n            // HACK: If there are enough files, it's almost certainly not a directory that contains collections. It's probably the user's data instead\n            if (dirs.includes(\".git\") || dirs.includes(\"data\") || alls.length > 100) {\n                base = await base.getDirectoryHandle(\"data\", { create: true });\n            }\n        }\n    }\n    for (let part of pathStr.split(\"/\")) {\n        if (!part) continue;\n        base = await base.getDirectoryHandle(part, { create: true });\n    }\n    return wrapHandle(base);\n});\nexport const getFileStorage = lazy(async function getFileStorage(): Promise<FileStorage> {\n    if (USE_INDEXED_DB) {\n        return await getFileStorageIndexDB();\n    }\n    let handle = await getDirectoryHandle();\n    return wrapHandle(handle);\n});\nexport function resetStorageLocation() {\n    if (opfsEnabled) {\n        // Don't delete previous folder — listPrivateFolders / pickPrivateFolder still need it. Just point\n        // \"current\" at a fresh timestamp-named one so the next reload starts clean.\n        setCurrentOpfsFolder(new Date().toISOString().replace(/[:.]/g, \"-\"));\n        window.location.reload();\n        return;\n    }\n    localStorage.removeItem(getFileAPIKey());\n    try { localStorage.removeItem(remoteConfigKey()); } catch { /* ignore */ }\n    window.location.reload();\n}\n\nexport type NestedFileStorage = {\n    hasKey(key: string): Promise<boolean>;\n    getStorage(key: string): Promise<FileStorage>;\n    removeStorage(key: string): Promise<void>;\n    getKeys(includeFolders?: boolean): Promise<string[]>;\n};\n\nexport type FileStorage = IStorageRaw & {\n    folder: NestedFileStorage;\n    // Mirrors DirectoryWrapper.isRemote: true when this storage is served over the network. Lets callers\n    // (e.g. BulkDatabase2, which skips automatic compaction over the network by default) adapt.\n    isRemote?: boolean;\n};\n\nlet appendQueue = cache((key: string) => {\n    return runInSerial((fnc: () => Promise<void>) => fnc());\n});\n\n\nasync function fixedGetFileHandle(config: {\n    handle: DirectoryWrapper;\n    key: string;\n    create: true;\n}): Promise<FileWrapper>;\nasync function fixedGetFileHandle(config: {\n    handle: DirectoryWrapper;\n    key: string;\n    create?: boolean;\n}): Promise<FileWrapper | undefined>;\nasync function fixedGetFileHandle(config: {\n    handle: DirectoryWrapper;\n    key: string;\n    create?: boolean;\n}): Promise<FileWrapper | undefined> {\n    if (config.key.includes(\"/\")) {\n        throw new Error(`Cannot use folders directly in file system read / writes. Use a wrapper which handles the folder navigation. Path was ${JSON.stringify(config.key)}`);\n    }\n    // ALWAYS try without create, because the sshfs-win sucks and doesn't support `create: true`? Wtf...\n    try {\n        return await config.handle.getFileHandle(config.key);\n    } catch {\n        if (!config.create) return undefined;\n    }\n    return await config.handle.getFileHandle(config.key, { create: true });\n}\n\n// A file that genuinely does not exist. We must NOT retry these, otherwise reading many missing\n// files (a common pattern) gets catastrophically slow.\nfunction isMissingError(error: unknown): boolean {\n    let name = (error as { name?: string })?.name;\n    let code = (error as { code?: string })?.code;\n    return name === \"NotFoundError\" || code === \"ENOENT\";\n}\n\nconst MAX_READ_RETRIES = 6;\n\n// The browser File System Access API can transiently fail reads under heavy load (it appears to\n// throttle when a page issues many reads at once). Those failures surface as errors OTHER than\n// \"not found\", so we retry them with backoff. A real missing file (NotFoundError / ENOENT) returns\n// undefined immediately with no retry.\nasync function readWithRetry<T>(label: string, key: string, read: () => Promise<T>): Promise<T | undefined> {\n    let backoff = 25;\n    for (let attempt = 0; ; attempt++) {\n        try {\n            return await read();\n        } catch (error) {\n            if (isMissingError(error)) return undefined;\n            let name = (error as { name?: string })?.name || \"Error\";\n            let message = (error as { message?: string })?.message || String(error);\n            if (attempt >= MAX_READ_RETRIES) {\n                console.warn(`${label} gave up on ${JSON.stringify(key)} after ${attempt} retries (${name}): ${message.slice(0, 200)}`);\n                return undefined;\n            }\n            console.warn(`${label} retrying ${JSON.stringify(key)} (attempt ${attempt + 1}, ${name}): ${message.slice(0, 200)}`);\n            await new Promise(resolve => setTimeout(resolve, backoff));\n            backoff = Math.min(backoff * 2, 1000);\n        }\n    }\n}\n\nfunction wrapHandleFiles(handle: DirectoryWrapper): IStorageRaw {\n    // Log the full path (root + filename) when available, so a failing file is identifiable.\n    const pathOf = (key: string) => handle.fullPath ? handle.fullPath + \"/\" + key : key;\n    return {\n        async getInfo(key: string) {\n            return readWithRetry(\"getInfo\", pathOf(key), async () => {\n                const file = await handle.getFileHandle(key);\n                const fileContent = await file.getFile();\n                return {\n                    size: fileContent.size,\n                    lastModified: fileContent.lastModified,\n                };\n            });\n        },\n        async get(key: string): Promise<Buffer | undefined> {\n            return readWithRetry(\"get\", pathOf(key), async () => {\n                const file = await handle.getFileHandle(key);\n                const fileContent = await file.getFile();\n                const arrayBuffer = await fileContent.arrayBuffer();\n                // Under load the FS Access API can resolve with a truncated buffer and no error.\n                //  Treat a short read as transient so readWithRetry retries it.\n                if (arrayBuffer.byteLength !== fileContent.size) {\n                    throw Object.assign(new Error(`Short read: got ${arrayBuffer.byteLength} of ${fileContent.size} bytes`), { name: \"ShortReadError\" });\n                }\n                return Buffer.from(arrayBuffer);\n            });\n        },\n\n        async getRange(key: string, config: { start: number; end: number }): Promise<Buffer | undefined> {\n            return readWithRetry(\"getRange\", pathOf(key), async () => {\n                const file = await handle.getFileHandle(key);\n                const fileContent = await file.getFile();\n                const clampedStart = Math.min(Math.max(config.start, 0), fileContent.size);\n                const clampedEnd = Math.min(Math.max(config.end, clampedStart), fileContent.size);\n                const arrayBuffer = await fileContent.slice(config.start, config.end).arrayBuffer();\n                if (arrayBuffer.byteLength !== clampedEnd - clampedStart) {\n                    throw Object.assign(new Error(`Short range read: got ${arrayBuffer.byteLength} of ${clampedEnd - clampedStart} bytes`), { name: \"ShortReadError\" });\n                }\n                return Buffer.from(arrayBuffer);\n            });\n        },\n\n        async append(key: string, value: Buffer): Promise<void> {\n            await appendQueue(key)(async () => {\n                // NOTE: Interesting point. Chrome doesn't optimize this to be an append, and instead\n                //  rewrites the entire file.\n                const file = await fixedGetFileHandle({ handle, key, create: true });\n                const writable = await file.createWritable({ keepExistingData: true });\n                let offset = (await file.getFile()).size;\n                await writable.seek(offset);\n                await writable.write(value);\n                await writable.close();\n            });\n        },\n\n        async set(key: string, value: Buffer): Promise<void> {\n            const file = await fixedGetFileHandle({ handle, key, create: true });\n            const writable = await file.createWritable();\n            await writable.write(value);\n            await writable.close();\n        },\n\n        async remove(key: string): Promise<void> {\n            await handle.removeEntry(key);\n        },\n\n        async getKeys(includeFolders: boolean = false): Promise<string[]> {\n            const keys: string[] = [];\n            try {\n                for await (const [name, entry] of handle) {\n                    if (entry.kind === \"file\" || includeFolders) {\n                        keys.push(entry.name);\n                    }\n                }\n            } catch (error) {\n                let name = (error as { name?: string })?.name || \"Error\";\n                let message = (error as { message?: string })?.message || String(error);\n                // A failure mid-iteration would silently truncate the listing, so surface it loudly.\n                console.error(`getKeys directory iteration failed after ${keys.length} entries (${name}): ${message.slice(0, 300)}`);\n                throw error;\n            }\n            return keys;\n        },\n\n        async reset() {\n            for await (const [name, entry] of handle) {\n                await handle.removeEntry(entry.name, { recursive: true });\n            }\n        },\n    };\n}\n\nfunction wrapHandleNested(handle: DirectoryWrapper): NestedFileStorage {\n    return {\n        async hasKey(key: string): Promise<boolean> {\n            try {\n                await handle.getDirectoryHandle(key);\n                return true;\n            } catch (error) {\n                return false;\n            }\n        },\n\n        async getStorage(key: string): Promise<FileStorage> {\n            const subDirectory = await handle.getDirectoryHandle(key, { create: true });\n            return wrapHandle(subDirectory);\n        },\n\n        async removeStorage(key: string): Promise<void> {\n            await handle.removeEntry(key, { recursive: true });\n        },\n\n        async getKeys(): Promise<string[]> {\n            const keys: string[] = [];\n            for await (const [name, entry] of handle) {\n                if (entry.kind === \"directory\") {\n                    keys.push(entry.name);\n                }\n            }\n            return keys;\n        },\n    };\n}\n\nexport function wrapHandle(handle: DirectoryWrapper): FileStorage {\n    return {\n        ...wrapHandleFiles(handle),\n        folder: wrapHandleNested(handle),\n        isRemote: handle.isRemote,\n    };\n}\n\n// Returns a URL for a file's bytes, ready to drop into <video>/<img>/fetch. A native (local) file becomes\n// an in-memory blob: URL; a remote file becomes an https URL into the server's range-capable /media\n// endpoint (auth token in the query, since a media element can't send headers). Both support HTTP range /\n// seeking. ALWAYS hand the result to disposeFileURL when finished — for blob: URLs that frees memory.\nexport async function getFileURL(file: FileWrapper): Promise<string> {\n    if (file.getURL) return file.getURL();\n    // Native FileSystemFileHandle (or any Blob-backed file): a blob: URL over the File itself.\n    const f = await file.getFile();\n    return URL.createObjectURL(f as unknown as Blob);\n}\n\n// Releases a URL from getFileURL. blob: URLs leak until the document is gone unless revoked; https/file:\n// URLs need no cleanup, so this is a no-op for them.\nexport function disposeFileURL(url: string): void {\n    if (url.startsWith(\"blob:\")) {\n        try { URL.revokeObjectURL(url); } catch { /* not in a browser, or already revoked */ }\n    }\n}\n\n// A StorageFactory backed by a remote server (path -> FileStorage), for code that injects its own\n// storage into BulkDatabase2 rather than going through the directory prompt.\nexport function getRemoteFileStorageFactory(url: string, password: string, options?: RemoteOptions): (pathStr: string) => Promise<FileStorage> {\n    const root = getRemoteDirectoryHandle(url, password, options);\n    return async (pathStr: string) => {\n        let base: DirectoryWrapper = root;\n        for (const part of pathStr.replaceAll(\"\\\\\", \"/\").split(\"/\")) {\n            if (!part) continue;\n            base = await base.getDirectoryHandle(part, { create: true });\n        }\n        return wrapHandle(base);\n    };\n}\n\nexport async function tryToLoadPointer(pointer: string) {\n    let result = await getFileSystemPointer({ pointer });\n    if (!result) return;\n    let handle = await result?.onUserActivation();\n    if (!handle) return;\n    return handle as any as DirectoryWrapper;\n}"]}
+ /* _JS_SOURCE_HASH = "43cb0c3dd5b191683c168a59e5117a62eee04ed66ca81588a27c8ad1fd491142"; */