@milaboratories/pl-drivers 1.11.59 → 1.11.61

package/dist/drivers/download_blob/download_blob.js

@@ -1,463 +1,398 @@
-import { Computable, ChangeSource } from '@milaboratories/computable';
-import { stringifyWithResourceId, resourceIdToString, isNotFoundError } from '@milaboratories/pl-client';
-import { validateRangeBytes } from '@milaboratories/pl-model-common';
-import { treeEntryToResourceInfo, isPlTreeEntry, makeResourceSnapshot } from '@milaboratories/pl-tree';
-import { TaskProcessor, mapGet, CallersCounter } from '@milaboratories/ts-helpers';
-import Denque from 'denque';
-import * as fs from 'node:fs';
-import { randomUUID } from 'node:crypto';
-import * as fsp from 'node:fs/promises';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import * as readline from 'node:readline/promises';
-import { buffer } from 'node:stream/consumers';
-import { withFileContent } from '../helpers/read_file.js';
-import { newLocalHandle, parseLocalHandle, isLocalBlobHandle } from '../helpers/download_local_handle.js';
-import { newRemoteHandle, isRemoteBlobHandle, parseRemoteHandle } from '../helpers/download_remote_handle.js';
-import { WrongResourceTypeError, Updater } from '../helpers/helpers.js';
-import { newLogHandle, getResourceInfoFromLogHandle } from '../helpers/logs_handle.js';
-import { OnDemandBlobResourceSnapshot, getSize } from '../types.js';
-import { blobKey, pathToKey } from './blob_key.js';
-import { DownloadBlobTask, nonRecoverableError } from './download_blob_task.js';
-import { FilesCache } from '../helpers/files_cache.js';
-import { SparseCacheFsRanges, SparseCacheFsFile, SparseCache } from './sparse_cache/cache.js';
-import { isOffByOneError } from '../../helpers/download_errors.js';
+import { isOffByOneError } from "../../helpers/download_errors.js";
+import { withFileContent } from "../helpers/read_file.js";
+import { isLocalBlobHandle, newLocalHandle, parseLocalHandle } from "../helpers/download_local_handle.js";
+import { OnDemandBlobResourceSnapshot, getSize } from "../types.js";
+import { isRemoteBlobHandle, newRemoteHandle, parseRemoteHandle } from "../helpers/download_remote_handle.js";
+import { Updater, WrongResourceTypeError } from "../helpers/helpers.js";
+import { getResourceInfoFromLogHandle, newLogHandle } from "../helpers/logs_handle.js";
+import { blobKey, pathToKey } from "./blob_key.js";
+import { DownloadBlobTask, nonRecoverableError } from "./download_blob_task.js";
+import { FilesCache } from "../helpers/files_cache.js";
+import { SparseCache, SparseCacheFsFile, SparseCacheFsRanges } from "./sparse_cache/cache.js";
+import { isNotFoundError, resourceIdToString, stringifyWithResourceId } from "@milaboratories/pl-client";
+import * as fsp from "node:fs/promises";
+import { CallersCounter, TaskProcessor, mapGet } from "@milaboratories/ts-helpers";
+import * as path$1 from "node:path";
+import { buffer } from "node:stream/consumers";
+import { ChangeSource, Computable } from "@milaboratories/computable";
+import { validateRangeBytes } from "@milaboratories/pl-model-common";
+import { isPlTreeEntry, makeResourceSnapshot, treeEntryToResourceInfo } from "@milaboratories/pl-tree";
+import Denque from "denque";
+import * as fs$1 from "fs";
+import { randomUUID } from "node:crypto";
+import * as os from "node:os";
+import * as readline from "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 FilesCache(this.ops.cacheSoftSizeBytes);
-        const fsRanges = new SparseCacheFsRanges(this.logger, this.rangesCacheDir);
-        const fsStorage = new SparseCacheFsFile(this.logger, this.rangesCacheDir);
-        this.rangesCache = new SparseCache(this.logger, this.ops.rangesCacheMaxSizeBytes, fsRanges, fsStorage);
-        this.downloadQueue = new TaskProcessor(this.logger, ops.nConcurrentDownloads);
-        this.saveDir = 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 === undefined) {
-            return Computable.make((ctx) => this.getDownloadedBlob(res, ctx));
-        }
-        const rInfo = treeEntryToResourceInfo(res, ctx);
-        const callerId = 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 = 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.resolve(this.saveDir, key);
-        const newTask = new DownloadBlobTask(this.logger, this.clientDownload, rInfo, newLocalHandle(fPath, this.signer), fPath);
-        this.keyToDownload.set(key, newTask);
-        this.downloadQueue.push({
-            fn: () => this.downloadBlob(newTask, callerId),
-            recoverableErrorPredicate: (e) => !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.make((ctx) => this.getOnDemandBlob(res, ctx));
-        const rInfo = isPlTreeEntry(res)
-            ? makeResourceSnapshot(res, OnDemandBlobResourceSnapshot, ctx)
-            : res;
-        const callerId = 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(blobKey(info.id));
-        if (blob === undefined) {
-            blob = new OnDemandBlobHolder(getSize(info), newRemoteHandle(info, this.signer));
-            this.keyToOnDemand.set(blobKey(info.id), blob);
-        }
-        blob.attach(callerId);
-        return blob.getHandle();
-    }
-    /** Gets a path from a handle. */
-    getLocalPath(handle) {
-        const { path } = 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;
-                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 (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 (isLocalBlobHandle(handle)) {
-            return await withFileContent({ path: this.getLocalPath(handle), range, signal, handler });
-        }
-        if (isRemoteBlobHandle(handle)) {
-            const result = parseRemoteHandle(handle, this.signer);
-            const key = blobKey(result.info.id);
-            const filePath = await this.rangesCache.get(key, range ?? { from: 0, to: result.size });
-            signal?.throwIfAborted();
-            if (filePath)
-                return await 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);
-                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) {
-            validateRangeBytes(range, `getComputableContent`);
-        }
-        return 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.make((ctx) => this.getLastLogs(res, lines, ctx));
-        const r = treeEntryToResourceInfo(res, ctx);
-        const callerId = 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 } = parseLocalHandle(blob.handle, this.signer);
-        let logGetter = this.idToLastLines.get(blobKey(rInfo.id));
-        if (logGetter == undefined) {
-            const newLogGetter = new LastLinesGetter(path, lines);
-            this.idToLastLines.set(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.make((ctx) => this.getProgressLog(res, patternToSearch, ctx));
-        const r = treeEntryToResourceInfo(res, ctx);
-        const callerId = 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 } = parseLocalHandle(blob.handle, this.signer);
-        let logGetter = this.idToProgressLog.get(blobKey(rInfo.id));
-        if (logGetter == undefined) {
-            const newLogGetter = new LastLinesGetter(path, 1, patternToSearch);
-            this.idToProgressLog.set(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.make((ctx) => this.getLogHandle(res, ctx));
-        const r = treeEntryToResourceInfo(res, ctx);
-        return this.getLogHandleNoCtx(r);
-    }
-    getLogHandleNoCtx(rInfo) {
-        validateDownloadableResourceType("getLogHandle", rInfo.type);
-        return newLogHandle(false, rInfo);
-    }
-    async lastLines(handle, lineCount, offsetBytes, // if 0n, then start from the end.
-    searchStr) {
-        const resp = await this.clientLogs.lastLines(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(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(blobKey(rInfo.id));
-        if (task == undefined) {
-            return;
-        }
-        if (this.cache.existsFile(blobKey(rInfo.id))) {
-            const toDelete = this.cache.removeFile(blobKey(rInfo.id), callerId);
-            await Promise.all(toDelete.map(async (cachedFile) => {
-                await fsp.rm(cachedFile.path);
-                this.cache.removeCache(cachedFile);
-                this.removeTask(mapGet(this.keyToDownload, pathToKey(cachedFile.path)), `the task ${stringifyWithResourceId(cachedFile)} was removed` +
-                    `from cache along with ${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 ${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(pathToKey(task.path));
-        this.idToLastLines.delete(blobKey(task.rInfo.id));
-        this.idToProgressLog.delete(blobKey(task.rInfo.id));
-    }
-    async releaseOnDemandBlob(blobId, callerId) {
-        const deleted = this.keyToOnDemand.get(blobKey(blobId))?.release(callerId) ?? false;
-        if (deleted)
-            this.keyToOnDemand.delete(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 ${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 FilesCache(this.ops.cacheSoftSizeBytes);
+		const fsRanges = new SparseCacheFsRanges(this.logger, this.rangesCacheDir);
+		const fsStorage = new SparseCacheFsFile(this.logger, this.rangesCacheDir);
+		this.rangesCache = new SparseCache(this.logger, this.ops.rangesCacheMaxSizeBytes, fsRanges, fsStorage);
+		this.downloadQueue = new TaskProcessor(this.logger, ops.nConcurrentDownloads);
+		this.saveDir = path$1.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 Computable.make((ctx) => this.getDownloadedBlob(res, ctx));
+		const rInfo = treeEntryToResourceInfo(res, ctx);
+		const callerId = 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 = blobKey(rInfo.id);
+		const inMemoryTask = this.keyToDownload.get(key);
+		if (inMemoryTask) return inMemoryTask;
+		const fPath = path$1.resolve(this.saveDir, key);
+		const newTask = new DownloadBlobTask(this.logger, this.clientDownload, rInfo, newLocalHandle(fPath, this.signer), fPath);
+		this.keyToDownload.set(key, newTask);
+		this.downloadQueue.push({
+			fn: () => this.downloadBlob(newTask, callerId),
+			recoverableErrorPredicate: (e) => !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 Computable.make((ctx) => this.getOnDemandBlob(res, ctx));
+		const rInfo = isPlTreeEntry(res) ? makeResourceSnapshot(res, OnDemandBlobResourceSnapshot, ctx) : res;
+		const callerId = 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(blobKey(info.id));
+		if (blob === void 0) {
+			blob = new OnDemandBlobHolder(getSize(info), newRemoteHandle(info, this.signer));
+			this.keyToOnDemand.set(blobKey(info.id), blob);
+		}
+		blob.attach(callerId);
+		return blob.getHandle();
+	}
+	/** Gets a path from a handle. */
+	getLocalPath(handle) {
+		const { path } = 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;
+			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 (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 (isLocalBlobHandle(handle)) return await withFileContent({
+			path: this.getLocalPath(handle),
+			range,
+			signal,
+			handler
+		});
+		if (isRemoteBlobHandle(handle)) {
+			const result = parseRemoteHandle(handle, this.signer);
+			const key = blobKey(result.info.id);
+			const filePath = await this.rangesCache.get(key, range ?? {
+				from: 0,
+				to: result.size
+			});
+			signal?.throwIfAborted();
+			if (filePath) return await 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);
+				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) validateRangeBytes(range, `getComputableContent`);
+		return 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 Computable.make((ctx) => this.getLastLogs(res, lines, ctx));
+		const r = treeEntryToResourceInfo(res, ctx);
+		const callerId = 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 } = parseLocalHandle(blob.handle, this.signer);
+		let logGetter = this.idToLastLines.get(blobKey(rInfo.id));
+		if (logGetter == void 0) {
+			const newLogGetter = new LastLinesGetter(path, lines);
+			this.idToLastLines.set(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 Computable.make((ctx) => this.getProgressLog(res, patternToSearch, ctx));
+		const r = treeEntryToResourceInfo(res, ctx);
+		const callerId = 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 } = parseLocalHandle(blob.handle, this.signer);
+		let logGetter = this.idToProgressLog.get(blobKey(rInfo.id));
+		if (logGetter == void 0) {
+			const newLogGetter = new LastLinesGetter(path, 1, patternToSearch);
+			this.idToProgressLog.set(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 Computable.make((ctx) => this.getLogHandle(res, ctx));
+		const r = treeEntryToResourceInfo(res, ctx);
+		return this.getLogHandleNoCtx(r);
+	}
+	getLogHandleNoCtx(rInfo) {
+		validateDownloadableResourceType("getLogHandle", rInfo.type);
+		return newLogHandle(false, rInfo);
+	}
+	async lastLines(handle, lineCount, offsetBytes, searchStr) {
+		const resp = await this.clientLogs.lastLines(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(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(blobKey(rInfo.id));
+		if (task == void 0) return;
+		if (this.cache.existsFile(blobKey(rInfo.id))) {
+			const toDelete = this.cache.removeFile(blobKey(rInfo.id), callerId);
+			await Promise.all(toDelete.map(async (cachedFile) => {
+				await fsp.rm(cachedFile.path);
+				this.cache.removeCache(cachedFile);
+				this.removeTask(mapGet(this.keyToDownload, pathToKey(cachedFile.path)), `the task ${stringifyWithResourceId(cachedFile)} was removedfrom cache along with ${stringifyWithResourceId(toDelete.map((d) => d.path))}`);
+			}));
+		} else if (task.counter.dec(callerId)) this.removeTask(task, `the task ${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(pathToKey(task.path));
+		this.idToLastLines.delete(blobKey(task.rInfo.id));
+		this.idToProgressLog.delete(blobKey(task.rInfo.id));
+	}
+	async releaseOnDemandBlob(blobId, callerId) {
+		if (this.keyToOnDemand.get(blobKey(blobId))?.release(callerId) ?? false) this.keyToOnDemand.delete(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 ${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 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 ChangeSource();
-    error = undefined;
-    constructor(path, lines, patternToSearch) {
-        this.path = path;
-        this.lines = lines;
-        this.patternToSearch = patternToSearch;
-        this.updater = new 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 (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 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 ChangeSource();
+	error = void 0;
+	constructor(path, lines, patternToSearch) {
+		this.path = path;
+		this.lines = lines;
+		this.patternToSearch = patternToSearch;
+		this.updater = new 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 (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.createReadStream(fPath);
-        rl = readline.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.EOL) + os.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$1.createReadStream(fPath);
+		rl = readline.createInterface({
+			input: inStream,
+			crlfDelay: Infinity
+		});
+		const lines = new Denque();
+		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(os.EOL) + 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 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 WrongResourceTypeError(message);
+	}
 }
 
+//#endregion
 export { DownloadDriver };
-//# sourceMappingURL=download_blob.js.map
+//# sourceMappingURL=download_blob.js.map