@milaboratories/pl-drivers 1.11.59 → 1.11.60

package/dist/drivers/download_blob/download_blob.cjs

@@ -1,488 +1,405 @@
-'use strict';
-
-var computable = require('@milaboratories/computable');
-var plClient = require('@milaboratories/pl-client');
-var plModelCommon = require('@milaboratories/pl-model-common');
-var plTree = require('@milaboratories/pl-tree');
-var tsHelpers = require('@milaboratories/ts-helpers');
-var Denque = require('denque');
-var fs = require('node:fs');
-var node_crypto = require('node:crypto');
-var fsp = require('node:fs/promises');
-var os = require('node:os');
-var path = require('node:path');
-var readline = require('node:readline/promises');
-var consumers = require('node:stream/consumers');
-var read_file = require('../helpers/read_file.cjs');
-var download_local_handle = require('../helpers/download_local_handle.cjs');
-var download_remote_handle = require('../helpers/download_remote_handle.cjs');
-var helpers = require('../helpers/helpers.cjs');
-var logs_handle = require('../helpers/logs_handle.cjs');
-var types = require('../types.cjs');
-var blob_key = require('./blob_key.cjs');
-var download_blob_task = require('./download_blob_task.cjs');
-var files_cache = require('../helpers/files_cache.cjs');
-var cache = require('./sparse_cache/cache.cjs');
-var download_errors = require('../../helpers/download_errors.cjs');
-
-function _interopNamespaceDefault(e) {
-    var n = Object.create(null);
-    if (e) {
-        Object.keys(e).forEach(function (k) {
-            if (k !== 'default') {
-                var d = Object.getOwnPropertyDescriptor(e, k);
-                Object.defineProperty(n, k, d.get ? d : {
-                    enumerable: true,
-                    get: function () { return e[k]; }
-                });
-            }
-        });
-    }
-    n.default = e;
-    return Object.freeze(n);
-}
-
-var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
-var fsp__namespace = /*#__PURE__*/_interopNamespaceDefault(fsp);
-var os__namespace = /*#__PURE__*/_interopNamespaceDefault(os);
-var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
-var readline__namespace = /*#__PURE__*/_interopNamespaceDefault(readline);
+const require_runtime = require('../../_virtual/_rolldown/runtime.cjs');
+const require_download_errors = require('../../helpers/download_errors.cjs');
+const require_read_file = require('../helpers/read_file.cjs');
+const require_download_local_handle = require('../helpers/download_local_handle.cjs');
+const require_types = require('../types.cjs');
+const require_download_remote_handle = require('../helpers/download_remote_handle.cjs');
+const require_helpers = require('../helpers/helpers.cjs');
+const require_logs_handle = require('../helpers/logs_handle.cjs');
+const require_blob_key = require('./blob_key.cjs');
+const require_download_blob_task = require('./download_blob_task.cjs');
+const require_files_cache = require('../helpers/files_cache.cjs');
+const require_cache = require('./sparse_cache/cache.cjs');
+let _milaboratories_pl_client = require("@milaboratories/pl-client");
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = require_runtime.__toESM(node_fs_promises);
+let _milaboratories_ts_helpers = require("@milaboratories/ts-helpers");
+let node_path = require("node:path");
+node_path = require_runtime.__toESM(node_path);
+let node_stream_consumers = require("node:stream/consumers");
+let _milaboratories_computable = require("@milaboratories/computable");
+let _milaboratories_pl_model_common = require("@milaboratories/pl-model-common");
+let _milaboratories_pl_tree = require("@milaboratories/pl-tree");
+let denque = require("denque");
+denque = require_runtime.__toESM(denque);
+let fs = require("fs");
+fs = require_runtime.__toESM(fs);
+let node_crypto = require("node:crypto");
+let node_os = require("node:os");
+node_os = require_runtime.__toESM(node_os);
+let node_readline_promises = require("node:readline/promises");
+node_readline_promises = require_runtime.__toESM(node_readline_promises);
 
+//#region src/drivers/download_blob/download_blob.ts
 /** DownloadDriver holds a queue of downloading tasks,
- * and notifies every watcher when a file were downloaded. */
-class DownloadDriver {
-    logger;
-    clientDownload;
-    clientLogs;
-    rangesCacheDir;
-    signer;
-    ops;
-    /** Represents a unique key to the path of a blob as a map. */
-    keyToDownload = new Map();
-    /** Writes and removes files to a hard drive and holds a counter for every
-     * file that should be kept. */
-    cache;
-    rangesCache;
-    /** Downloads files and writes them to the local dir. */
-    downloadQueue;
-    keyToOnDemand = new Map();
-    idToLastLines = new Map();
-    idToProgressLog = new Map();
-    saveDir;
-    constructor(logger, clientDownload, clientLogs, saveDir, rangesCacheDir, signer, ops) {
-        this.logger = logger;
-        this.clientDownload = clientDownload;
-        this.clientLogs = clientLogs;
-        this.rangesCacheDir = rangesCacheDir;
-        this.signer = signer;
-        this.ops = ops;
-        this.cache = new files_cache.FilesCache(this.ops.cacheSoftSizeBytes);
-        const fsRanges = new cache.SparseCacheFsRanges(this.logger, this.rangesCacheDir);
-        const fsStorage = new cache.SparseCacheFsFile(this.logger, this.rangesCacheDir);
-        this.rangesCache = new cache.SparseCache(this.logger, this.ops.rangesCacheMaxSizeBytes, fsRanges, fsStorage);
-        this.downloadQueue = new tsHelpers.TaskProcessor(this.logger, ops.nConcurrentDownloads);
-        this.saveDir = path__namespace.resolve(saveDir);
-    }
-    static async init(logger, clientDownload, clientLogs, saveDir, rangesCacheDir, signer, ops) {
-        const driver = new DownloadDriver(logger, clientDownload, clientLogs, saveDir, rangesCacheDir, signer, ops);
-        await driver.rangesCache.reset();
-        return driver;
-    }
-    getDownloadedBlob(res, ctx) {
-        if (ctx === undefined) {
-            return computable.Computable.make((ctx) => this.getDownloadedBlob(res, ctx));
-        }
-        const rInfo = plTree.treeEntryToResourceInfo(res, ctx);
-        const callerId = node_crypto.randomUUID();
-        ctx.addOnDestroy(() => this.releaseBlob(rInfo, callerId));
-        const result = this.getDownloadedBlobNoCtx(ctx.watcher, rInfo, callerId);
-        if (result == undefined) {
-            ctx.markUnstable("download blob is still undefined");
-        }
-        return result;
-    }
-    getDownloadedBlobNoCtx(w, rInfo, callerId) {
-        validateDownloadableResourceType("getDownloadedBlob", rInfo.type);
-        // We don't need to request files with wider limits,
-        // PFrame's engine does it disk-optimally by itself.
-        const task = this.getOrSetNewTask(rInfo, callerId);
-        task.attach(w, callerId);
-        const result = task.getBlob();
-        if (!result.done) {
-            return undefined;
-        }
-        if (result.result.ok) {
-            return result.result.value;
-        }
-        throw result.result.error;
-    }
-    getOrSetNewTask(rInfo, callerId) {
-        const key = blob_key.blobKey(rInfo.id);
-        const inMemoryTask = this.keyToDownload.get(key);
-        if (inMemoryTask) {
-            return inMemoryTask;
-        }
-        // schedule the blob downloading, then it'll be added to the cache.
-        const fPath = path__namespace.resolve(this.saveDir, key);
-        const newTask = new download_blob_task.DownloadBlobTask(this.logger, this.clientDownload, rInfo, download_local_handle.newLocalHandle(fPath, this.signer), fPath);
-        this.keyToDownload.set(key, newTask);
-        this.downloadQueue.push({
-            fn: () => this.downloadBlob(newTask, callerId),
-            recoverableErrorPredicate: (e) => !download_blob_task.nonRecoverableError(e),
-        });
-        return newTask;
-    }
-    async downloadBlob(task, callerId) {
-        await task.download();
-        const blob = task.getBlob();
-        if (blob.done && blob.result.ok) {
-            this.cache.addCache(task, callerId);
-        }
-    }
-    getOnDemandBlob(res, ctx) {
-        if (ctx === undefined)
-            return computable.Computable.make((ctx) => this.getOnDemandBlob(res, ctx));
-        const rInfo = plTree.isPlTreeEntry(res)
-            ? plTree.makeResourceSnapshot(res, types.OnDemandBlobResourceSnapshot, ctx)
-            : res;
-        const callerId = node_crypto.randomUUID();
-        ctx.addOnDestroy(() => this.releaseOnDemandBlob(rInfo.id, callerId));
-        // note that the watcher is not needed,
-        // the handler never changes.
-        const result = this.getOnDemandBlobNoCtx(rInfo, callerId);
-        return result;
-    }
-    getOnDemandBlobNoCtx(info, callerId) {
-        validateDownloadableResourceType("getOnDemandBlob", info.type);
-        let blob = this.keyToOnDemand.get(blob_key.blobKey(info.id));
-        if (blob === undefined) {
-            blob = new OnDemandBlobHolder(types.getSize(info), download_remote_handle.newRemoteHandle(info, this.signer));
-            this.keyToOnDemand.set(blob_key.blobKey(info.id), blob);
-        }
-        blob.attach(callerId);
-        return blob.getHandle();
-    }
-    /** Gets a path from a handle. */
-    getLocalPath(handle) {
-        const { path } = download_local_handle.parseLocalHandle(handle, this.signer);
-        return path;
-    }
-    async getContent(handle, optionsOrRange) {
-        let options = {};
-        if (typeof optionsOrRange === "object" && optionsOrRange !== null) {
-            if ("range" in optionsOrRange) {
-                options = optionsOrRange;
-            }
-            else {
-                const range = optionsOrRange;
-                plModelCommon.validateRangeBytes(range, `getContent`);
-                options = { range };
-            }
-        }
-        const request = () => this.withContent(handle, {
-            ...options,
-            handler: async (content) => {
-                const chunks = [];
-                for await (const chunk of content) {
-                    options.signal?.throwIfAborted();
-                    chunks.push(chunk);
-                }
-                return Buffer.concat(chunks);
-            },
-        });
-        try {
-            return await request();
-        }
-        catch (error) {
-            if (download_errors.isOffByOneError(error)) {
-                return await request();
-            }
-            throw error;
-        }
-    }
-    /** Gets a content stream of a blob by a handle and calls handler with it. */
-    async withContent(handle, options) {
-        const { range, signal, handler } = options;
-        if (download_local_handle.isLocalBlobHandle(handle)) {
-            return await read_file.withFileContent({ path: this.getLocalPath(handle), range, signal, handler });
-        }
-        if (download_remote_handle.isRemoteBlobHandle(handle)) {
-            const result = download_remote_handle.parseRemoteHandle(handle, this.signer);
-            const key = blob_key.blobKey(result.info.id);
-            const filePath = await this.rangesCache.get(key, range ?? { from: 0, to: result.size });
-            signal?.throwIfAborted();
-            if (filePath)
-                return await read_file.withFileContent({ path: filePath, range, signal, handler });
-            return await this.clientDownload.withBlobContent(result.info, { signal }, options, async (content, size) => {
-                const [handlerStream, cacheStream] = content.tee();
-                const handlerPromise = handler(handlerStream, size);
-                consumers.buffer(cacheStream)
-                    .then((data) => this.rangesCache.set(key, range ?? { from: 0, to: result.size }, data))
-                    .catch(() => {
-                    // Ignore cache errors - they shouldn't affect the main handler result
-                    // This prevents unhandled promise rejections when the stream fails
-                });
-                return await handlerPromise;
-            });
-        }
-        throw new Error("Malformed remote handle");
-    }
-    /**
-     * Creates computable that will return blob content once it is downloaded.
-     * Uses downloaded blob handle under the hood, so stores corresponding blob in file system.
-     */
-    getComputableContent(res, range) {
-        if (range) {
-            plModelCommon.validateRangeBytes(range, `getComputableContent`);
-        }
-        return computable.Computable.make((ctx) => this.getDownloadedBlob(res, ctx), {
-            postprocessValue: (v) => (v ? this.getContent(v.handle, { range }) : undefined),
-        }).withStableType();
-    }
-    getLastLogs(res, lines, ctx) {
-        if (ctx == undefined)
-            return computable.Computable.make((ctx) => this.getLastLogs(res, lines, ctx));
-        const r = plTree.treeEntryToResourceInfo(res, ctx);
-        const callerId = node_crypto.randomUUID();
-        ctx.addOnDestroy(() => this.releaseBlob(r, callerId));
-        const result = this.getLastLogsNoCtx(ctx.watcher, r, lines, callerId);
-        if (result == undefined)
-            ctx.markUnstable("either a file was not downloaded or logs was not read");
-        return result;
-    }
-    getLastLogsNoCtx(w, rInfo, lines, callerId) {
-        validateDownloadableResourceType("getLastLogs", rInfo.type);
-        const blob = this.getDownloadedBlobNoCtx(w, rInfo, callerId);
-        if (blob == undefined)
-            return undefined;
-        const { path } = download_local_handle.parseLocalHandle(blob.handle, this.signer);
-        let logGetter = this.idToLastLines.get(blob_key.blobKey(rInfo.id));
-        if (logGetter == undefined) {
-            const newLogGetter = new LastLinesGetter(path, lines);
-            this.idToLastLines.set(blob_key.blobKey(rInfo.id), newLogGetter);
-            logGetter = newLogGetter;
-        }
-        const result = logGetter.getOrSchedule(w);
-        if (result.error)
-            throw result.error;
-        return result.log;
-    }
-    getProgressLog(res, patternToSearch, ctx) {
-        if (ctx == undefined)
-            return computable.Computable.make((ctx) => this.getProgressLog(res, patternToSearch, ctx));
-        const r = plTree.treeEntryToResourceInfo(res, ctx);
-        const callerId = node_crypto.randomUUID();
-        ctx.addOnDestroy(() => this.releaseBlob(r, callerId));
-        const result = this.getProgressLogNoCtx(ctx.watcher, r, patternToSearch, callerId);
-        if (result === undefined)
-            ctx.markUnstable("either a file was not downloaded or a progress log was not read");
-        return result;
-    }
-    getProgressLogNoCtx(w, rInfo, patternToSearch, callerId) {
-        validateDownloadableResourceType("getProgressLog", rInfo.type);
-        const blob = this.getDownloadedBlobNoCtx(w, rInfo, callerId);
-        if (blob == undefined)
-            return undefined;
-        const { path } = download_local_handle.parseLocalHandle(blob.handle, this.signer);
-        let logGetter = this.idToProgressLog.get(blob_key.blobKey(rInfo.id));
-        if (logGetter == undefined) {
-            const newLogGetter = new LastLinesGetter(path, 1, patternToSearch);
-            this.idToProgressLog.set(blob_key.blobKey(rInfo.id), newLogGetter);
-            logGetter = newLogGetter;
-        }
-        const result = logGetter.getOrSchedule(w);
-        if (result.error)
-            throw result.error;
-        return result.log;
-    }
-    getLogHandle(res, ctx) {
-        if (ctx == undefined)
-            return computable.Computable.make((ctx) => this.getLogHandle(res, ctx));
-        const r = plTree.treeEntryToResourceInfo(res, ctx);
-        return this.getLogHandleNoCtx(r);
-    }
-    getLogHandleNoCtx(rInfo) {
-        validateDownloadableResourceType("getLogHandle", rInfo.type);
-        return logs_handle.newLogHandle(false, rInfo);
-    }
-    async lastLines(handle, lineCount, offsetBytes, // if 0n, then start from the end.
-    searchStr) {
-        const resp = await this.clientLogs.lastLines(logs_handle.getResourceInfoFromLogHandle(handle), lineCount, BigInt(offsetBytes ?? 0), searchStr);
-        return {
-            live: false,
-            shouldUpdateHandle: false,
-            data: resp.data,
-            size: Number(resp.size),
-            newOffset: Number(resp.newOffset),
-        };
-    }
-    async readText(handle, lineCount, offsetBytes, searchStr) {
-        const resp = await this.clientLogs.readText(logs_handle.getResourceInfoFromLogHandle(handle), lineCount, BigInt(offsetBytes ?? 0), searchStr);
-        return {
-            live: false,
-            shouldUpdateHandle: false,
-            data: resp.data,
-            size: Number(resp.size),
-            newOffset: Number(resp.newOffset),
-        };
-    }
-    async releaseBlob(rInfo, callerId) {
-        const task = this.keyToDownload.get(blob_key.blobKey(rInfo.id));
-        if (task == undefined) {
-            return;
-        }
-        if (this.cache.existsFile(blob_key.blobKey(rInfo.id))) {
-            const toDelete = this.cache.removeFile(blob_key.blobKey(rInfo.id), callerId);
-            await Promise.all(toDelete.map(async (cachedFile) => {
-                await fsp__namespace.rm(cachedFile.path);
-                this.cache.removeCache(cachedFile);
-                this.removeTask(tsHelpers.mapGet(this.keyToDownload, blob_key.pathToKey(cachedFile.path)), `the task ${plClient.stringifyWithResourceId(cachedFile)} was removed` +
-                    `from cache along with ${plClient.stringifyWithResourceId(toDelete.map((d) => d.path))}`);
-            }));
-        }
-        else {
-            // The task is still in a downloading queue.
-            const deleted = task.counter.dec(callerId);
-            if (deleted) {
-                this.removeTask(task, `the task ${plClient.stringifyWithResourceId(task.info())} was removed from cache`);
-            }
-        }
-    }
-    removeTask(task, reason) {
-        task.abort(reason);
-        task.change.markChanged(`download task for ${task.path} removed: ${reason}`);
-        this.keyToDownload.delete(blob_key.pathToKey(task.path));
-        this.idToLastLines.delete(blob_key.blobKey(task.rInfo.id));
-        this.idToProgressLog.delete(blob_key.blobKey(task.rInfo.id));
-    }
-    async releaseOnDemandBlob(blobId, callerId) {
-        const deleted = this.keyToOnDemand.get(blob_key.blobKey(blobId))?.release(callerId) ?? false;
-        if (deleted)
-            this.keyToOnDemand.delete(blob_key.blobKey(blobId));
-    }
-    /** Removes all files from a hard drive. */
-    async releaseAll() {
-        this.downloadQueue.stop();
-        this.keyToDownload.forEach((task, key) => {
-            this.keyToDownload.delete(key);
-            task.change.markChanged(`task ${plClient.resourceIdToString(task.rInfo.id)} released`);
-        });
-    }
-    async dispose() {
-        await this.rangesCache.dispose();
-    }
-    async [Symbol.asyncDispose]() {
-        await this.dispose();
-    }
-}
+* and notifies every watcher when a file were downloaded. */
+var DownloadDriver = class DownloadDriver {
+	/** Represents a unique key to the path of a blob as a map. */
+	keyToDownload = /* @__PURE__ */ new Map();
+	/** Writes and removes files to a hard drive and holds a counter for every
+	* file that should be kept. */
+	cache;
+	rangesCache;
+	/** Downloads files and writes them to the local dir. */
+	downloadQueue;
+	keyToOnDemand = /* @__PURE__ */ new Map();
+	idToLastLines = /* @__PURE__ */ new Map();
+	idToProgressLog = /* @__PURE__ */ new Map();
+	saveDir;
+	constructor(logger, clientDownload, clientLogs, saveDir, rangesCacheDir, signer, ops) {
+		this.logger = logger;
+		this.clientDownload = clientDownload;
+		this.clientLogs = clientLogs;
+		this.rangesCacheDir = rangesCacheDir;
+		this.signer = signer;
+		this.ops = ops;
+		this.cache = new require_files_cache.FilesCache(this.ops.cacheSoftSizeBytes);
+		const fsRanges = new require_cache.SparseCacheFsRanges(this.logger, this.rangesCacheDir);
+		const fsStorage = new require_cache.SparseCacheFsFile(this.logger, this.rangesCacheDir);
+		this.rangesCache = new require_cache.SparseCache(this.logger, this.ops.rangesCacheMaxSizeBytes, fsRanges, fsStorage);
+		this.downloadQueue = new _milaboratories_ts_helpers.TaskProcessor(this.logger, ops.nConcurrentDownloads);
+		this.saveDir = node_path.resolve(saveDir);
+	}
+	static async init(logger, clientDownload, clientLogs, saveDir, rangesCacheDir, signer, ops) {
+		const driver = new DownloadDriver(logger, clientDownload, clientLogs, saveDir, rangesCacheDir, signer, ops);
+		await driver.rangesCache.reset();
+		return driver;
+	}
+	getDownloadedBlob(res, ctx) {
+		if (ctx === void 0) return _milaboratories_computable.Computable.make((ctx) => this.getDownloadedBlob(res, ctx));
+		const rInfo = (0, _milaboratories_pl_tree.treeEntryToResourceInfo)(res, ctx);
+		const callerId = (0, node_crypto.randomUUID)();
+		ctx.addOnDestroy(() => this.releaseBlob(rInfo, callerId));
+		const result = this.getDownloadedBlobNoCtx(ctx.watcher, rInfo, callerId);
+		if (result == void 0) ctx.markUnstable("download blob is still undefined");
+		return result;
+	}
+	getDownloadedBlobNoCtx(w, rInfo, callerId) {
+		validateDownloadableResourceType("getDownloadedBlob", rInfo.type);
+		const task = this.getOrSetNewTask(rInfo, callerId);
+		task.attach(w, callerId);
+		const result = task.getBlob();
+		if (!result.done) return;
+		if (result.result.ok) return result.result.value;
+		throw result.result.error;
+	}
+	getOrSetNewTask(rInfo, callerId) {
+		const key = require_blob_key.blobKey(rInfo.id);
+		const inMemoryTask = this.keyToDownload.get(key);
+		if (inMemoryTask) return inMemoryTask;
+		const fPath = node_path.resolve(this.saveDir, key);
+		const newTask = new require_download_blob_task.DownloadBlobTask(this.logger, this.clientDownload, rInfo, require_download_local_handle.newLocalHandle(fPath, this.signer), fPath);
+		this.keyToDownload.set(key, newTask);
+		this.downloadQueue.push({
+			fn: () => this.downloadBlob(newTask, callerId),
+			recoverableErrorPredicate: (e) => !require_download_blob_task.nonRecoverableError(e)
+		});
+		return newTask;
+	}
+	async downloadBlob(task, callerId) {
+		await task.download();
+		const blob = task.getBlob();
+		if (blob.done && blob.result.ok) this.cache.addCache(task, callerId);
+	}
+	getOnDemandBlob(res, ctx) {
+		if (ctx === void 0) return _milaboratories_computable.Computable.make((ctx) => this.getOnDemandBlob(res, ctx));
+		const rInfo = (0, _milaboratories_pl_tree.isPlTreeEntry)(res) ? (0, _milaboratories_pl_tree.makeResourceSnapshot)(res, require_types.OnDemandBlobResourceSnapshot, ctx) : res;
+		const callerId = (0, node_crypto.randomUUID)();
+		ctx.addOnDestroy(() => this.releaseOnDemandBlob(rInfo.id, callerId));
+		return this.getOnDemandBlobNoCtx(rInfo, callerId);
+	}
+	getOnDemandBlobNoCtx(info, callerId) {
+		validateDownloadableResourceType("getOnDemandBlob", info.type);
+		let blob = this.keyToOnDemand.get(require_blob_key.blobKey(info.id));
+		if (blob === void 0) {
+			blob = new OnDemandBlobHolder(require_types.getSize(info), require_download_remote_handle.newRemoteHandle(info, this.signer));
+			this.keyToOnDemand.set(require_blob_key.blobKey(info.id), blob);
+		}
+		blob.attach(callerId);
+		return blob.getHandle();
+	}
+	/** Gets a path from a handle. */
+	getLocalPath(handle) {
+		const { path } = require_download_local_handle.parseLocalHandle(handle, this.signer);
+		return path;
+	}
+	async getContent(handle, optionsOrRange) {
+		let options = {};
+		if (typeof optionsOrRange === "object" && optionsOrRange !== null) if ("range" in optionsOrRange) options = optionsOrRange;
+		else {
+			const range = optionsOrRange;
+			(0, _milaboratories_pl_model_common.validateRangeBytes)(range, `getContent`);
+			options = { range };
+		}
+		const request = () => this.withContent(handle, {
+			...options,
+			handler: async (content) => {
+				const chunks = [];
+				for await (const chunk of content) {
+					options.signal?.throwIfAborted();
+					chunks.push(chunk);
+				}
+				return Buffer.concat(chunks);
+			}
+		});
+		try {
+			return await request();
+		} catch (error) {
+			if (require_download_errors.isOffByOneError(error)) return await request();
+			throw error;
+		}
+	}
+	/** Gets a content stream of a blob by a handle and calls handler with it. */
+	async withContent(handle, options) {
+		const { range, signal, handler } = options;
+		if (require_download_local_handle.isLocalBlobHandle(handle)) return await require_read_file.withFileContent({
+			path: this.getLocalPath(handle),
+			range,
+			signal,
+			handler
+		});
+		if (require_download_remote_handle.isRemoteBlobHandle(handle)) {
+			const result = require_download_remote_handle.parseRemoteHandle(handle, this.signer);
+			const key = require_blob_key.blobKey(result.info.id);
+			const filePath = await this.rangesCache.get(key, range ?? {
+				from: 0,
+				to: result.size
+			});
+			signal?.throwIfAborted();
+			if (filePath) return await require_read_file.withFileContent({
+				path: filePath,
+				range,
+				signal,
+				handler
+			});
+			return await this.clientDownload.withBlobContent(result.info, { signal }, options, async (content, size) => {
+				const [handlerStream, cacheStream] = content.tee();
+				const handlerPromise = handler(handlerStream, size);
+				(0, node_stream_consumers.buffer)(cacheStream).then((data) => this.rangesCache.set(key, range ?? {
+					from: 0,
+					to: result.size
+				}, data)).catch(() => {});
+				return await handlerPromise;
+			});
+		}
+		throw new Error("Malformed remote handle");
+	}
+	/**
+	* Creates computable that will return blob content once it is downloaded.
+	* Uses downloaded blob handle under the hood, so stores corresponding blob in file system.
+	*/
+	getComputableContent(res, range) {
+		if (range) (0, _milaboratories_pl_model_common.validateRangeBytes)(range, `getComputableContent`);
+		return _milaboratories_computable.Computable.make((ctx) => this.getDownloadedBlob(res, ctx), { postprocessValue: (v) => v ? this.getContent(v.handle, { range }) : void 0 }).withStableType();
+	}
+	getLastLogs(res, lines, ctx) {
+		if (ctx == void 0) return _milaboratories_computable.Computable.make((ctx) => this.getLastLogs(res, lines, ctx));
+		const r = (0, _milaboratories_pl_tree.treeEntryToResourceInfo)(res, ctx);
+		const callerId = (0, node_crypto.randomUUID)();
+		ctx.addOnDestroy(() => this.releaseBlob(r, callerId));
+		const result = this.getLastLogsNoCtx(ctx.watcher, r, lines, callerId);
+		if (result == void 0) ctx.markUnstable("either a file was not downloaded or logs was not read");
+		return result;
+	}
+	getLastLogsNoCtx(w, rInfo, lines, callerId) {
+		validateDownloadableResourceType("getLastLogs", rInfo.type);
+		const blob = this.getDownloadedBlobNoCtx(w, rInfo, callerId);
+		if (blob == void 0) return void 0;
+		const { path } = require_download_local_handle.parseLocalHandle(blob.handle, this.signer);
+		let logGetter = this.idToLastLines.get(require_blob_key.blobKey(rInfo.id));
+		if (logGetter == void 0) {
+			const newLogGetter = new LastLinesGetter(path, lines);
+			this.idToLastLines.set(require_blob_key.blobKey(rInfo.id), newLogGetter);
+			logGetter = newLogGetter;
+		}
+		const result = logGetter.getOrSchedule(w);
+		if (result.error) throw result.error;
+		return result.log;
+	}
+	getProgressLog(res, patternToSearch, ctx) {
+		if (ctx == void 0) return _milaboratories_computable.Computable.make((ctx) => this.getProgressLog(res, patternToSearch, ctx));
+		const r = (0, _milaboratories_pl_tree.treeEntryToResourceInfo)(res, ctx);
+		const callerId = (0, node_crypto.randomUUID)();
+		ctx.addOnDestroy(() => this.releaseBlob(r, callerId));
+		const result = this.getProgressLogNoCtx(ctx.watcher, r, patternToSearch, callerId);
+		if (result === void 0) ctx.markUnstable("either a file was not downloaded or a progress log was not read");
+		return result;
+	}
+	getProgressLogNoCtx(w, rInfo, patternToSearch, callerId) {
+		validateDownloadableResourceType("getProgressLog", rInfo.type);
+		const blob = this.getDownloadedBlobNoCtx(w, rInfo, callerId);
+		if (blob == void 0) return void 0;
+		const { path } = require_download_local_handle.parseLocalHandle(blob.handle, this.signer);
+		let logGetter = this.idToProgressLog.get(require_blob_key.blobKey(rInfo.id));
+		if (logGetter == void 0) {
+			const newLogGetter = new LastLinesGetter(path, 1, patternToSearch);
+			this.idToProgressLog.set(require_blob_key.blobKey(rInfo.id), newLogGetter);
+			logGetter = newLogGetter;
+		}
+		const result = logGetter.getOrSchedule(w);
+		if (result.error) throw result.error;
+		return result.log;
+	}
+	getLogHandle(res, ctx) {
+		if (ctx == void 0) return _milaboratories_computable.Computable.make((ctx) => this.getLogHandle(res, ctx));
+		const r = (0, _milaboratories_pl_tree.treeEntryToResourceInfo)(res, ctx);
+		return this.getLogHandleNoCtx(r);
+	}
+	getLogHandleNoCtx(rInfo) {
+		validateDownloadableResourceType("getLogHandle", rInfo.type);
+		return require_logs_handle.newLogHandle(false, rInfo);
+	}
+	async lastLines(handle, lineCount, offsetBytes, searchStr) {
+		const resp = await this.clientLogs.lastLines(require_logs_handle.getResourceInfoFromLogHandle(handle), lineCount, BigInt(offsetBytes ?? 0), searchStr);
+		return {
+			live: false,
+			shouldUpdateHandle: false,
+			data: resp.data,
+			size: Number(resp.size),
+			newOffset: Number(resp.newOffset)
+		};
+	}
+	async readText(handle, lineCount, offsetBytes, searchStr) {
+		const resp = await this.clientLogs.readText(require_logs_handle.getResourceInfoFromLogHandle(handle), lineCount, BigInt(offsetBytes ?? 0), searchStr);
+		return {
+			live: false,
+			shouldUpdateHandle: false,
+			data: resp.data,
+			size: Number(resp.size),
+			newOffset: Number(resp.newOffset)
+		};
+	}
+	async releaseBlob(rInfo, callerId) {
+		const task = this.keyToDownload.get(require_blob_key.blobKey(rInfo.id));
+		if (task == void 0) return;
+		if (this.cache.existsFile(require_blob_key.blobKey(rInfo.id))) {
+			const toDelete = this.cache.removeFile(require_blob_key.blobKey(rInfo.id), callerId);
+			await Promise.all(toDelete.map(async (cachedFile) => {
+				await node_fs_promises.rm(cachedFile.path);
+				this.cache.removeCache(cachedFile);
+				this.removeTask((0, _milaboratories_ts_helpers.mapGet)(this.keyToDownload, require_blob_key.pathToKey(cachedFile.path)), `the task ${(0, _milaboratories_pl_client.stringifyWithResourceId)(cachedFile)} was removedfrom cache along with ${(0, _milaboratories_pl_client.stringifyWithResourceId)(toDelete.map((d) => d.path))}`);
+			}));
+		} else if (task.counter.dec(callerId)) this.removeTask(task, `the task ${(0, _milaboratories_pl_client.stringifyWithResourceId)(task.info())} was removed from cache`);
+	}
+	removeTask(task, reason) {
+		task.abort(reason);
+		task.change.markChanged(`download task for ${task.path} removed: ${reason}`);
+		this.keyToDownload.delete(require_blob_key.pathToKey(task.path));
+		this.idToLastLines.delete(require_blob_key.blobKey(task.rInfo.id));
+		this.idToProgressLog.delete(require_blob_key.blobKey(task.rInfo.id));
+	}
+	async releaseOnDemandBlob(blobId, callerId) {
+		if (this.keyToOnDemand.get(require_blob_key.blobKey(blobId))?.release(callerId) ?? false) this.keyToOnDemand.delete(require_blob_key.blobKey(blobId));
+	}
+	/** Removes all files from a hard drive. */
+	async releaseAll() {
+		this.downloadQueue.stop();
+		this.keyToDownload.forEach((task, key) => {
+			this.keyToDownload.delete(key);
+			task.change.markChanged(`task ${(0, _milaboratories_pl_client.resourceIdToString)(task.rInfo.id)} released`);
+		});
+	}
+	async dispose() {
+		await this.rangesCache.dispose();
+	}
+	async [Symbol.asyncDispose]() {
+		await this.dispose();
+	}
+};
 /** Keeps a counter to the on demand handle. */
-class OnDemandBlobHolder {
-    size;
-    handle;
-    counter = new tsHelpers.CallersCounter();
-    constructor(size, handle) {
-        this.size = size;
-        this.handle = handle;
-    }
-    getHandle() {
-        return { handle: this.handle, size: this.size };
-    }
-    attach(callerId) {
-        this.counter.inc(callerId);
-    }
-    release(callerId) {
-        return this.counter.dec(callerId);
-    }
-}
-class LastLinesGetter {
-    path;
-    lines;
-    patternToSearch;
-    updater;
-    log;
-    change = new computable.ChangeSource();
-    error = undefined;
-    constructor(path, lines, patternToSearch) {
-        this.path = path;
-        this.lines = lines;
-        this.patternToSearch = patternToSearch;
-        this.updater = new helpers.Updater(async () => this.update());
-    }
-    getOrSchedule(w) {
-        this.change.attachWatcher(w);
-        this.updater.schedule();
-        return {
-            log: this.log,
-            error: this.error,
-        };
-    }
-    async update() {
-        try {
-            const newLogs = await getLastLines(this.path, this.lines, this.patternToSearch);
-            if (this.log != newLogs)
-                this.change.markChanged(`logs for ${this.path} updated`);
-            this.log = newLogs;
-        }
-        catch (e) {
-            if (plClient.isNotFoundError(e)) {
-                // No resource
-                this.log = "";
-                this.error = e;
-                this.change.markChanged(`log update for ${this.path} failed, resource not found`);
-                return;
-            }
-            throw e;
-        }
-    }
-}
+var OnDemandBlobHolder = class {
+	counter = new _milaboratories_ts_helpers.CallersCounter();
+	constructor(size, handle) {
+		this.size = size;
+		this.handle = handle;
+	}
+	getHandle() {
+		return {
+			handle: this.handle,
+			size: this.size
+		};
+	}
+	attach(callerId) {
+		this.counter.inc(callerId);
+	}
+	release(callerId) {
+		return this.counter.dec(callerId);
+	}
+};
+var LastLinesGetter = class {
+	updater;
+	log;
+	change = new _milaboratories_computable.ChangeSource();
+	error = void 0;
+	constructor(path, lines, patternToSearch) {
+		this.path = path;
+		this.lines = lines;
+		this.patternToSearch = patternToSearch;
+		this.updater = new require_helpers.Updater(async () => this.update());
+	}
+	getOrSchedule(w) {
+		this.change.attachWatcher(w);
+		this.updater.schedule();
+		return {
+			log: this.log,
+			error: this.error
+		};
+	}
+	async update() {
+		try {
+			const newLogs = await getLastLines(this.path, this.lines, this.patternToSearch);
+			if (this.log != newLogs) this.change.markChanged(`logs for ${this.path} updated`);
+			this.log = newLogs;
+		} catch (e) {
+			if ((0, _milaboratories_pl_client.isNotFoundError)(e)) {
+				this.log = "";
+				this.error = e;
+				this.change.markChanged(`log update for ${this.path} failed, resource not found`);
+				return;
+			}
+			throw e;
+		}
+	}
+};
 /** Gets last lines from a file by reading the file from the top and keeping
- * last N lines in a window queue. */
+* last N lines in a window queue. */
 async function getLastLines(fPath, nLines, patternToSearch) {
-    let inStream;
-    let rl;
-    try {
-        inStream = fs__namespace.createReadStream(fPath);
-        rl = readline__namespace.createInterface({ input: inStream, crlfDelay: Infinity });
-        const lines = new Denque();
-        for await (const line of rl) {
-            if (patternToSearch != undefined && !line.includes(patternToSearch))
-                continue;
-            lines.push(line);
-            if (lines.length > nLines) {
-                lines.shift();
-            }
-        }
-        // last EOL is for keeping backward compat with platforma implementation.
-        return lines.toArray().join(os__namespace.EOL) + os__namespace.EOL;
-    }
-    finally {
-        // Cleanup resources in finally block to ensure they're always cleaned up
-        try {
-            if (rl) {
-                rl.close();
-            }
-        }
-        catch (cleanupError) {
-            console.error("Error closing readline interface:", cleanupError);
-        }
-        try {
-            if (inStream && !inStream.destroyed) {
-                inStream.destroy();
-            }
-        }
-        catch (cleanupError) {
-            console.error("Error destroying read stream:", cleanupError);
-        }
-    }
+	let inStream;
+	let rl;
+	try {
+		inStream = fs.createReadStream(fPath);
+		rl = node_readline_promises.createInterface({
+			input: inStream,
+			crlfDelay: Infinity
+		});
+		const lines = new denque.default();
+		for await (const line of rl) {
+			if (patternToSearch != void 0 && !line.includes(patternToSearch)) continue;
+			lines.push(line);
+			if (lines.length > nLines) lines.shift();
+		}
+		return lines.toArray().join(node_os.EOL) + node_os.EOL;
+	} finally {
+		try {
+			if (rl) rl.close();
+		} catch (cleanupError) {
+			console.error("Error closing readline interface:", cleanupError);
+		}
+		try {
+			if (inStream && !inStream.destroyed) inStream.destroy();
+		} catch (cleanupError) {
+			console.error("Error destroying read stream:", cleanupError);
+		}
+	}
 }
 function validateDownloadableResourceType(methodName, rType) {
-    if (!rType.name.startsWith("Blob/")) {
-        let message = `${methodName}: wrong resource type: ${rType.name}, expected: a resource of type that starts with 'Blob/'.`;
-        if (rType.name == "Blob")
-            message += ` If it's called from workflow, should a file be exported with 'file.exportFile' function?`;
-        throw new helpers.WrongResourceTypeError(message);
-    }
+	if (!rType.name.startsWith("Blob/")) {
+		let message = `${methodName}: wrong resource type: ${rType.name}, expected: a resource of type that starts with 'Blob/'.`;
+		if (rType.name == "Blob") message += ` If it's called from workflow, should a file be exported with 'file.exportFile' function?`;
+		throw new require_helpers.WrongResourceTypeError(message);
+	}
 }
 
+//#endregion
 exports.DownloadDriver = DownloadDriver;
-//# sourceMappingURL=download_blob.cjs.map
+//# sourceMappingURL=download_blob.cjs.map