sliftutils 1.7.9 → 1.7.11

package/storage/dist/ArchivesDisk.ts.cache

@@ -0,0 +1,373 @@
+"use strict";
+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.applyFindInfoShape = exports.ArchivesDisk = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const caching_1 = require("socket-function/src/caching");
+const batching_1 = require("socket-function/src/batching");
+const misc_1 = require("socket-function/src/misc");
+const IArchives_1 = require("./IArchives");
+// The base file-system IArchives: storage is one-to-one with the file system, every key is exactly
+// one real file under <folder>/files, so the file system itself is the index. File handles are
+// cached and reused, and closed once idle (see FileHandleCache). All operations on a file run in
+// serial, so they can't collide with each other or with handle closing. Used as the disk
+// synchronization source of BlobStore (see remoteStorage/blobStore.ts).
+const HANDLE_IDLE_TIMEOUT = 1000 * 60;
+const HANDLE_SWEEP_INTERVAL = 1000 * 15;
+// Caches open file handles, closing them once idle for HANDLE_IDLE_TIMEOUT. Instead of one
+// setTimeout per handle, a list sorted by last use is swept periodically (entries are moved via
+// binary search on access, and lastUse values only increase, so touched entries append at the
+// end). Also serializes operations per file: each operation only starts once the previous one on
+// the same file finished, and a handle is never closed while an operation is pending on it.
+class FileHandleCache {
+    constructor() {
+        this.entries = new Map();
+        // Sorted by lastUse ascending (least recently used first)
+        this.lru = [];
+        this.pending = new Map();
+        (0, batching_1.runInfinitePoll)(HANDLE_SWEEP_INTERVAL, () => this.sweep());
+    }
+    // Runs fnc after every previously scheduled operation on filePath has finished
+    run(filePath, fnc) {
+        let prev = this.pending.get(filePath) || Promise.resolve();
+        let result = prev.then(fnc);
+        // The pending chain must never reject, or one failed operation would poison all later ones
+        let last = result.then(() => { }, () => { });
+        this.pending.set(filePath, last);
+        void last.then(() => {
+            // If we're still the last pending operation on this file, clear ourselves
+            if (this.pending.get(filePath) === last) {
+                this.pending.delete(filePath);
+            }
+        });
+        return result;
+    }
+    // Only call inside run() for the same filePath (so opens can't collide with closes)
+    async getHandle(filePath, flags) {
+        let entry = this.entries.get(filePath);
+        if (entry) {
+            this.removeFromLRU(entry);
+            entry.lastUse = Date.now();
+            this.lru.push(entry);
+            return entry.handle;
+        }
+        let handle = await fs_1.default.promises.open(filePath, flags);
+        entry = { filePath, handle, lastUse: Date.now() };
+        this.entries.set(filePath, entry);
+        this.lru.push(entry);
+        return handle;
+    }
+    // Only call inside run() for the same filePath
+    async closeNow(filePath) {
+        let entry = this.entries.get(filePath);
+        if (!entry)
+            return;
+        this.entries.delete(filePath);
+        this.removeFromLRU(entry);
+        await entry.handle.close();
+    }
+    removeFromLRU(entry) {
+        let index = (0, misc_1.binarySearchBasic)(this.lru, x => x.lastUse, entry.lastUse);
+        if (index < 0)
+            return;
+        // Multiple entries can share a lastUse, so scan for the exact one
+        while (index < this.lru.length && this.lru[index].lastUse === entry.lastUse) {
+            if (this.lru[index] === entry) {
+                this.lru.splice(index, 1);
+                return;
+            }
+            index++;
+        }
+    }
+    async sweep() {
+        let cutoff = Date.now() - HANDLE_IDLE_TIMEOUT;
+        let index = 0;
+        while (index < this.lru.length && this.lru[index].lastUse <= cutoff) {
+            let entry = this.lru[index];
+            // Can't close a handle with a pending operation; it'll be swept after it finishes
+            if (this.pending.has(entry.filePath)) {
+                index++;
+                continue;
+            }
+            this.lru.splice(index, 1);
+            this.entries.delete(entry.filePath);
+            await entry.handle.close();
+        }
+    }
+}
+class ArchivesDisk {
+    constructor(folder) {
+        this.folder = folder;
+        this.filesDir = path_1.default.join(this.folder, "files");
+        this.uploadsDir = path_1.default.join(this.folder, "uploads");
+        this.handles = new FileHandleCache();
+        this.largeUploads = new Map();
+        this.nextLargeUploadId = 1;
+        this.init = (0, caching_1.lazy)(async () => {
+            await fs_1.default.promises.mkdir(this.filesDir, { recursive: true });
+            await fs_1.default.promises.mkdir(this.uploadsDir, { recursive: true });
+            // Uploads don't survive restarts (the uploader streams into them), so old ones are garbage
+            for (let file of await fs_1.default.promises.readdir(this.uploadsDir)) {
+                await fs_1.default.promises.unlink(path_1.default.join(this.uploadsDir, file));
+            }
+        });
+    }
+    getDebugName() {
+        return `disk/${this.folder}`;
+    }
+    async getConfig() {
+        return {};
+    }
+    async hasWriteAccess() {
+        return true;
+    }
+    filePath(key) {
+        let result = path_1.default.join(this.filesDir, key);
+        if (!result.startsWith(this.filesDir + path_1.default.sep)) {
+            throw new Error(`Invalid key ${JSON.stringify(key.slice(0, 200))}, it escapes the store folder`);
+        }
+        return result;
+    }
+    async set(key, data, config) {
+        await this.init();
+        let lastModified = config === null || config === void 0 ? void 0 : config.lastModified;
+        if (lastModified) {
+            (0, IArchives_1.assertValidLastModified)(lastModified);
+        }
+        let filePath = this.filePath(key);
+        await this.handles.run(filePath, async () => {
+            if (lastModified) {
+                let existing = await statOrUndefined(filePath);
+                // An older write never overwrites a newer one (see IArchives.set)
+                if (existing && lastModified < existing.mtimeMs)
+                    return;
+            }
+            await fs_1.default.promises.mkdir(path_1.default.dirname(filePath), { recursive: true });
+            let handle = await this.handles.getHandle(filePath, fs_1.default.constants.O_RDWR | fs_1.default.constants.O_CREAT);
+            await handle.truncate(0);
+            await handle.write(data, 0, data.length, 0);
+            if (lastModified) {
+                await handle.utimes(new Date(lastModified), new Date(lastModified));
+            }
+        });
+    }
+    async del(key) {
+        await this.init();
+        let filePath = this.filePath(key);
+        await this.handles.run(filePath, async () => {
+            await this.handles.closeNow(filePath);
+            try {
+                await fs_1.default.promises.unlink(filePath);
+            }
+            catch (e) {
+                if (e.code !== "ENOENT")
+                    throw e;
+            }
+        });
+    }
+    async get(key, config) {
+        let result = await this.get2(key, config);
+        return result && result.data || undefined;
+    }
+    async get2(key, config) {
+        await this.init();
+        let range = config === null || config === void 0 ? void 0 : config.range;
+        let filePath = this.filePath(key);
+        return await this.handles.run(filePath, async () => {
+            let handle;
+            try {
+                handle = await this.handles.getHandle(filePath, fs_1.default.constants.O_RDWR);
+            }
+            catch (e) {
+                if (e.code === "ENOENT")
+                    return undefined;
+                throw e;
+            }
+            let stats = await handle.stat();
+            let size = stats.size;
+            let start = range && Math.min(range.start, size) || 0;
+            let end = range && Math.min(range.end, size) || size;
+            if (end <= start)
+                return { data: Buffer.alloc(0), writeTime: stats.mtimeMs, size };
+            let buffer = Buffer.alloc(end - start);
+            let { bytesRead } = await handle.read(buffer, 0, buffer.length, start);
+            if (bytesRead !== buffer.length) {
+                throw new Error(`Expected ${buffer.length} bytes at ${filePath}:${start}, read ${bytesRead}`);
+            }
+            return { data: buffer, writeTime: stats.mtimeMs, size };
+        });
+    }
+    async getInfo(key) {
+        await this.init();
+        let filePath = this.filePath(key);
+        return await this.handles.run(filePath, async () => {
+            let stats = await statOrUndefined(filePath);
+            if (!stats || !stats.isFile())
+                return undefined;
+            return { writeTime: stats.mtimeMs, size: stats.size };
+        });
+    }
+    async find(prefix, config) {
+        return (await this.findInfo(prefix, config)).map(x => x.path);
+    }
+    async findInfo(prefix, config) {
+        await this.init();
+        let infos = new Map();
+        await this.collectFiles("", prefix, infos);
+        let files = Array.from(infos.values());
+        files = applyFindInfoShape(files, prefix, config);
+        (0, misc_1.sort)(files, x => x.path);
+        return files;
+    }
+    // relDir is "" or ends with "/". Only descends into directories that can still match the prefix.
+    async collectFiles(relDir, prefix, infos) {
+        let entries;
+        try {
+            entries = await fs_1.default.promises.readdir(path_1.default.join(this.filesDir, relDir), { withFileTypes: true });
+        }
+        catch (e) {
+            if (e.code === "ENOENT")
+                return;
+            throw e;
+        }
+        for (let entry of entries) {
+            let relPath = relDir + entry.name;
+            if (entry.isDirectory()) {
+                let dirPath = relPath + "/";
+                if (dirPath.startsWith(prefix) || prefix.startsWith(dirPath)) {
+                    await this.collectFiles(dirPath, prefix, infos);
+                }
+                continue;
+            }
+            if (!entry.isFile())
+                continue;
+            if (!relPath.startsWith(prefix))
+                continue;
+            let stats = await statOrUndefined(path_1.default.join(this.filesDir, relPath));
+            // Deleted while we were walking
+            if (!stats)
+                continue;
+            infos.set(relPath, { path: relPath, createTime: stats.mtimeMs, size: stats.size });
+        }
+    }
+    async setLargeFile(config) {
+        let id = await this.startLargeUpload();
+        try {
+            while (true) {
+                let data = await config.getNextData();
+                if (!data)
+                    break;
+                await this.appendLargeUpload(id, data);
+            }
+            await this.finishLargeUpload(id, config.path);
+        }
+        catch (e) {
+            await this.cancelLargeUpload(id);
+            throw e;
+        }
+    }
+    // Large files stream into their own file under uploads/, then move into place on finish. No
+    // handle is opened until the first append actually happens.
+    async startLargeUpload() {
+        await this.init();
+        let id = `${Date.now()}_${this.nextLargeUploadId++}`;
+        this.largeUploads.set(id, { tmpPath: path_1.default.join(this.uploadsDir, `upload_${id}.tmp`) });
+        return id;
+    }
+    async appendLargeUpload(id, data) {
+        let upload = this.largeUploads.get(id);
+        if (!upload)
+            throw new Error(`Unknown large upload ${id}`);
+        const tmpPath = upload.tmpPath;
+        await this.handles.run(tmpPath, async () => {
+            let handle = await this.handles.getHandle(tmpPath, fs_1.default.constants.O_WRONLY | fs_1.default.constants.O_CREAT | fs_1.default.constants.O_APPEND);
+            await handle.write(data, 0, data.length);
+        });
+    }
+    async finishLargeUpload(id, key) {
+        let upload = this.largeUploads.get(id);
+        if (!upload)
+            throw new Error(`Unknown large upload ${id}`);
+        const tmpPath = upload.tmpPath;
+        this.largeUploads.delete(id);
+        let filePath = this.filePath(key);
+        await this.handles.run(tmpPath, () => this.handles.closeNow(tmpPath));
+        await this.handles.run(filePath, async () => {
+            // Close any cached handle to the file we're replacing, so later reads reopen the new file
+            await this.handles.closeNow(filePath);
+            await fs_1.default.promises.mkdir(path_1.default.dirname(filePath), { recursive: true });
+            try {
+                await fs_1.default.promises.rename(tmpPath, filePath);
+            }
+            catch (e) {
+                if (e.code !== "ENOENT")
+                    throw e;
+                // Nothing was ever appended, so the upload file was never created
+                await fs_1.default.promises.writeFile(filePath, Buffer.alloc(0));
+            }
+        });
+    }
+    async cancelLargeUpload(id) {
+        let upload = this.largeUploads.get(id);
+        if (!upload)
+            return;
+        const tmpPath = upload.tmpPath;
+        this.largeUploads.delete(id);
+        await this.handles.run(tmpPath, async () => {
+            await this.handles.closeNow(tmpPath);
+            try {
+                await fs_1.default.promises.unlink(tmpPath);
+            }
+            catch (e) {
+                if (e.code !== "ENOENT")
+                    throw e;
+            }
+        });
+    }
+    async getURL(path) {
+        throw new Error(`getURL is not supported for disk archives (${this.getDebugName()}, path ${path})`);
+    }
+}
+exports.ArchivesDisk = ArchivesDisk;
+async function statOrUndefined(filePath) {
+    try {
+        return await fs_1.default.promises.stat(filePath);
+    }
+    catch (e) {
+        if (e.code === "ENOENT")
+            return undefined;
+        throw e;
+    }
+}
+// The folders/shallow post-processing shared by findInfo implementations that list flat files
+// (used by ArchivesDisk on the raw disk walk, and by BlobStore on its index).
+function applyFindInfoShape(files, prefix, config) {
+    if ((config === null || config === void 0 ? void 0 : config.type) === "folders") {
+        let folders = new Map();
+        for (let file of files) {
+            let rest = file.path.slice(prefix.length);
+            let restParts = rest.split("/");
+            if (restParts.length < 2)
+                continue;
+            let folder;
+            if (config.shallow) {
+                folder = prefix + restParts[0];
+            }
+            else {
+                folder = file.path.split("/").slice(0, -1).join("/");
+            }
+            folders.set(folder, { path: folder, createTime: file.createTime, size: file.size });
+        }
+        return Array.from(folders.values());
+    }
+    if (config === null || config === void 0 ? void 0 : config.shallow) {
+        return files.filter(file => !file.path.slice(prefix.length).includes("/"));
+    }
+    return files;
+}
+exports.applyFindInfoShape = applyFindInfoShape;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ArchivesDisk.js","sourceRoot":"","sources":["ArchivesDisk.ts"],"names":[],"mappings":"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","sourcesContent":["import fs from \"fs\";\nimport path from \"path\";\nimport { lazy } from \"socket-function/src/caching\";\nimport { runInfinitePoll } from \"socket-function/src/batching\";\nimport { sort, binarySearchBasic } from \"socket-function/src/misc\";\nimport { IArchives, ArchiveFileInfo, ArchivesConfig, assertValidLastModified } from \"./IArchives\";\n\n// The base file-system IArchives: storage is one-to-one with the file system, every key is exactly\n// one real file under <folder>/files, so the file system itself is the index. File handles are\n// cached and reused, and closed once idle (see FileHandleCache). All operations on a file run in\n// serial, so they can't collide with each other or with handle closing. Used as the disk\n// synchronization source of BlobStore (see remoteStorage/blobStore.ts).\n\nconst HANDLE_IDLE_TIMEOUT = 1000 * 60;\nconst HANDLE_SWEEP_INTERVAL = 1000 * 15;\n\ntype HandleEntry = {\n    filePath: string;\n    handle: fs.promises.FileHandle;\n    lastUse: number;\n};\n\n// Caches open file handles, closing them once idle for HANDLE_IDLE_TIMEOUT. Instead of one\n// setTimeout per handle, a list sorted by last use is swept periodically (entries are moved via\n// binary search on access, and lastUse values only increase, so touched entries append at the\n// end). Also serializes operations per file: each operation only starts once the previous one on\n// the same file finished, and a handle is never closed while an operation is pending on it.\nclass FileHandleCache {\n    private entries = new Map<string, HandleEntry>();\n    // Sorted by lastUse ascending (least recently used first)\n    private lru: HandleEntry[] = [];\n    private pending = new Map<string, Promise<void>>();\n\n    constructor() {\n        runInfinitePoll(HANDLE_SWEEP_INTERVAL, () => this.sweep());\n    }\n\n    // Runs fnc after every previously scheduled operation on filePath has finished\n    public run<T>(filePath: string, fnc: () => Promise<T>): Promise<T> {\n        let prev = this.pending.get(filePath) || Promise.resolve();\n        let result = prev.then(fnc);\n        // The pending chain must never reject, or one failed operation would poison all later ones\n        let last = result.then(() => { }, () => { });\n        this.pending.set(filePath, last);\n        void last.then(() => {\n            // If we're still the last pending operation on this file, clear ourselves\n            if (this.pending.get(filePath) === last) {\n                this.pending.delete(filePath);\n            }\n        });\n        return result;\n    }\n\n    // Only call inside run() for the same filePath (so opens can't collide with closes)\n    public async getHandle(filePath: string, flags: number): Promise<fs.promises.FileHandle> {\n        let entry = this.entries.get(filePath);\n        if (entry) {\n            this.removeFromLRU(entry);\n            entry.lastUse = Date.now();\n            this.lru.push(entry);\n            return entry.handle;\n        }\n        let handle = await fs.promises.open(filePath, flags);\n        entry = { filePath, handle, lastUse: Date.now() };\n        this.entries.set(filePath, entry);\n        this.lru.push(entry);\n        return handle;\n    }\n\n    // Only call inside run() for the same filePath\n    public async closeNow(filePath: string): Promise<void> {\n        let entry = this.entries.get(filePath);\n        if (!entry) return;\n        this.entries.delete(filePath);\n        this.removeFromLRU(entry);\n        await entry.handle.close();\n    }\n\n    private removeFromLRU(entry: HandleEntry) {\n        let index = binarySearchBasic(this.lru, x => x.lastUse, entry.lastUse);\n        if (index < 0) return;\n        // Multiple entries can share a lastUse, so scan for the exact one\n        while (index < this.lru.length && this.lru[index].lastUse === entry.lastUse) {\n            if (this.lru[index] === entry) {\n                this.lru.splice(index, 1);\n                return;\n            }\n            index++;\n        }\n    }\n\n    private async sweep(): Promise<void> {\n        let cutoff = Date.now() - HANDLE_IDLE_TIMEOUT;\n        let index = 0;\n        while (index < this.lru.length && this.lru[index].lastUse <= cutoff) {\n            let entry = this.lru[index];\n            // Can't close a handle with a pending operation; it'll be swept after it finishes\n            if (this.pending.has(entry.filePath)) {\n                index++;\n                continue;\n            }\n            this.lru.splice(index, 1);\n            this.entries.delete(entry.filePath);\n            await entry.handle.close();\n        }\n    }\n}\n\nexport class ArchivesDisk implements IArchives {\n    constructor(private folder: string) { }\n\n    private filesDir = path.join(this.folder, \"files\");\n    private uploadsDir = path.join(this.folder, \"uploads\");\n    private handles = new FileHandleCache();\n    private largeUploads = new Map<string, { tmpPath: string }>();\n    private nextLargeUploadId = 1;\n\n    public init = lazy(async () => {\n        await fs.promises.mkdir(this.filesDir, { recursive: true });\n        await fs.promises.mkdir(this.uploadsDir, { recursive: true });\n        // Uploads don't survive restarts (the uploader streams into them), so old ones are garbage\n        for (let file of await fs.promises.readdir(this.uploadsDir)) {\n            await fs.promises.unlink(path.join(this.uploadsDir, file));\n        }\n    });\n\n    public getDebugName() {\n        return `disk/${this.folder}`;\n    }\n\n    public async getConfig(): Promise<ArchivesConfig> {\n        return {};\n    }\n\n    public async hasWriteAccess(): Promise<boolean> {\n        return true;\n    }\n\n    private filePath(key: string): string {\n        let result = path.join(this.filesDir, key);\n        if (!result.startsWith(this.filesDir + path.sep)) {\n            throw new Error(`Invalid key ${JSON.stringify(key.slice(0, 200))}, it escapes the store folder`);\n        }\n        return result;\n    }\n\n    public async set(key: string, data: Buffer, config?: { lastModified?: number }): Promise<void> {\n        await this.init();\n        let lastModified = config?.lastModified;\n        if (lastModified) {\n            assertValidLastModified(lastModified);\n        }\n        let filePath = this.filePath(key);\n        await this.handles.run(filePath, async () => {\n            if (lastModified) {\n                let existing = await statOrUndefined(filePath);\n                // An older write never overwrites a newer one (see IArchives.set)\n                if (existing && lastModified < existing.mtimeMs) return;\n            }\n            await fs.promises.mkdir(path.dirname(filePath), { recursive: true });\n            let handle = await this.handles.getHandle(filePath, fs.constants.O_RDWR | fs.constants.O_CREAT);\n            await handle.truncate(0);\n            await handle.write(data, 0, data.length, 0);\n            if (lastModified) {\n                await handle.utimes(new Date(lastModified), new Date(lastModified));\n            }\n        });\n    }\n\n    public async del(key: string): Promise<void> {\n        await this.init();\n        let filePath = this.filePath(key);\n        await this.handles.run(filePath, async () => {\n            await this.handles.closeNow(filePath);\n            try {\n                await fs.promises.unlink(filePath);\n            } catch (e: any) {\n                if (e.code !== \"ENOENT\") throw e;\n            }\n        });\n    }\n\n    public async get(key: string, config?: { range?: { start: number; end: number } }): Promise<Buffer | undefined> {\n        let result = await this.get2(key, config);\n        return result && result.data || undefined;\n    }\n\n    public async get2(key: string, config?: { range?: { start: number; end: number } }): Promise<{ data: Buffer; writeTime: number; size: number } | undefined> {\n        await this.init();\n        let range = config?.range;\n        let filePath = this.filePath(key);\n        return await this.handles.run(filePath, async () => {\n            let handle: fs.promises.FileHandle;\n            try {\n                handle = await this.handles.getHandle(filePath, fs.constants.O_RDWR);\n            } catch (e: any) {\n                if (e.code === \"ENOENT\") return undefined;\n                throw e;\n            }\n            let stats = await handle.stat();\n            let size = stats.size;\n            let start = range && Math.min(range.start, size) || 0;\n            let end = range && Math.min(range.end, size) || size;\n            if (end <= start) return { data: Buffer.alloc(0), writeTime: stats.mtimeMs, size };\n            let buffer = Buffer.alloc(end - start);\n            let { bytesRead } = await handle.read(buffer, 0, buffer.length, start);\n            if (bytesRead !== buffer.length) {\n                throw new Error(`Expected ${buffer.length} bytes at ${filePath}:${start}, read ${bytesRead}`);\n            }\n            return { data: buffer, writeTime: stats.mtimeMs, size };\n        });\n    }\n\n    public async getInfo(key: string): Promise<{ writeTime: number; size: number } | undefined> {\n        await this.init();\n        let filePath = this.filePath(key);\n        return await this.handles.run(filePath, async () => {\n            let stats = await statOrUndefined(filePath);\n            if (!stats || !stats.isFile()) return undefined;\n            return { writeTime: stats.mtimeMs, size: stats.size };\n        });\n    }\n\n    public async find(prefix: string, config?: { shallow?: boolean; type: \"files\" | \"folders\" }): Promise<string[]> {\n        return (await this.findInfo(prefix, config)).map(x => x.path);\n    }\n\n    public async findInfo(prefix: string, config?: { shallow?: boolean; type?: \"files\" | \"folders\" }): Promise<ArchiveFileInfo[]> {\n        await this.init();\n        let infos = new Map<string, ArchiveFileInfo>();\n        await this.collectFiles(\"\", prefix, infos);\n        let files = Array.from(infos.values());\n        files = applyFindInfoShape(files, prefix, config);\n        sort(files, x => x.path);\n        return files;\n    }\n\n    // relDir is \"\" or ends with \"/\". Only descends into directories that can still match the prefix.\n    private async collectFiles(relDir: string, prefix: string, infos: Map<string, ArchiveFileInfo>): Promise<void> {\n        let entries: fs.Dirent[];\n        try {\n            entries = await fs.promises.readdir(path.join(this.filesDir, relDir), { withFileTypes: true });\n        } catch (e: any) {\n            if (e.code === \"ENOENT\") return;\n            throw e;\n        }\n        for (let entry of entries) {\n            let relPath = relDir + entry.name;\n            if (entry.isDirectory()) {\n                let dirPath = relPath + \"/\";\n                if (dirPath.startsWith(prefix) || prefix.startsWith(dirPath)) {\n                    await this.collectFiles(dirPath, prefix, infos);\n                }\n                continue;\n            }\n            if (!entry.isFile()) continue;\n            if (!relPath.startsWith(prefix)) continue;\n            let stats = await statOrUndefined(path.join(this.filesDir, relPath));\n            // Deleted while we were walking\n            if (!stats) continue;\n            infos.set(relPath, { path: relPath, createTime: stats.mtimeMs, size: stats.size });\n        }\n    }\n\n    public async setLargeFile(config: { path: string; getNextData(): Promise<Buffer | undefined> }): Promise<void> {\n        let id = await this.startLargeUpload();\n        try {\n            while (true) {\n                let data = await config.getNextData();\n                if (!data) break;\n                await this.appendLargeUpload(id, data);\n            }\n            await this.finishLargeUpload(id, config.path);\n        } catch (e) {\n            await this.cancelLargeUpload(id);\n            throw e;\n        }\n    }\n\n    // Large files stream into their own file under uploads/, then move into place on finish. No\n    // handle is opened until the first append actually happens.\n    public async startLargeUpload(): Promise<string> {\n        await this.init();\n        let id = `${Date.now()}_${this.nextLargeUploadId++}`;\n        this.largeUploads.set(id, { tmpPath: path.join(this.uploadsDir, `upload_${id}.tmp`) });\n        return id;\n    }\n    public async appendLargeUpload(id: string, data: Buffer): Promise<void> {\n        let upload = this.largeUploads.get(id);\n        if (!upload) throw new Error(`Unknown large upload ${id}`);\n        const tmpPath = upload.tmpPath;\n        await this.handles.run(tmpPath, async () => {\n            let handle = await this.handles.getHandle(tmpPath, fs.constants.O_WRONLY | fs.constants.O_CREAT | fs.constants.O_APPEND);\n            await handle.write(data, 0, data.length);\n        });\n    }\n    public async finishLargeUpload(id: string, key: string): Promise<void> {\n        let upload = this.largeUploads.get(id);\n        if (!upload) throw new Error(`Unknown large upload ${id}`);\n        const tmpPath = upload.tmpPath;\n        this.largeUploads.delete(id);\n        let filePath = this.filePath(key);\n        await this.handles.run(tmpPath, () => this.handles.closeNow(tmpPath));\n        await this.handles.run(filePath, async () => {\n            // Close any cached handle to the file we're replacing, so later reads reopen the new file\n            await this.handles.closeNow(filePath);\n            await fs.promises.mkdir(path.dirname(filePath), { recursive: true });\n            try {\n                await fs.promises.rename(tmpPath, filePath);\n            } catch (e: any) {\n                if (e.code !== \"ENOENT\") throw e;\n                // Nothing was ever appended, so the upload file was never created\n                await fs.promises.writeFile(filePath, Buffer.alloc(0));\n            }\n        });\n    }\n    public async cancelLargeUpload(id: string): Promise<void> {\n        let upload = this.largeUploads.get(id);\n        if (!upload) return;\n        const tmpPath = upload.tmpPath;\n        this.largeUploads.delete(id);\n        await this.handles.run(tmpPath, async () => {\n            await this.handles.closeNow(tmpPath);\n            try {\n                await fs.promises.unlink(tmpPath);\n            } catch (e: any) {\n                if (e.code !== \"ENOENT\") throw e;\n            }\n        });\n    }\n\n    public async getURL(path: string): Promise<string> {\n        throw new Error(`getURL is not supported for disk archives (${this.getDebugName()}, path ${path})`);\n    }\n}\n\nasync function statOrUndefined(filePath: string): Promise<fs.Stats | undefined> {\n    try {\n        return await fs.promises.stat(filePath);\n    } catch (e: any) {\n        if (e.code === \"ENOENT\") return undefined;\n        throw e;\n    }\n}\n\n// The folders/shallow post-processing shared by findInfo implementations that list flat files\n// (used by ArchivesDisk on the raw disk walk, and by BlobStore on its index).\nexport function applyFindInfoShape(files: ArchiveFileInfo[], prefix: string, config?: { shallow?: boolean; type?: \"files\" | \"folders\" }): ArchiveFileInfo[] {\n    if (config?.type === \"folders\") {\n        let folders = new Map<string, ArchiveFileInfo>();\n        for (let file of files) {\n            let rest = file.path.slice(prefix.length);\n            let restParts = rest.split(\"/\");\n            if (restParts.length < 2) continue;\n            let folder: string;\n            if (config.shallow) {\n                folder = prefix + restParts[0];\n            } else {\n                folder = file.path.split(\"/\").slice(0, -1).join(\"/\");\n            }\n            folders.set(folder, { path: folder, createTime: file.createTime, size: file.size });\n        }\n        return Array.from(folders.values());\n    }\n    if (config?.shallow) {\n        return files.filter(file => !file.path.slice(prefix.length).includes(\"/\"));\n    }\n    return files;\n}\n"]}
+ /* _JS_SOURCE_HASH = "9e9a4bb7586f9d75283eaf57d9a71e2ffd25ef1ea107a52ec483353eb71dc468"; */