@milaboratories/pl-drivers 1.5.10 → 1.5.12

package/src/drivers/download_blob.ts

@@ -1,12 +1,15 @@
-import {
-  ChangeSource,
-  Computable,
+import type {
   ComputableCtx,
   ComputableStableDefined,
-  Watcher
+  Watcher,
 } from '@milaboratories/computable';
-import { ResourceId, ResourceType, stringifyWithResourceId } from '@milaboratories/pl-client';
 import {
+  ChangeSource,
+  Computable,
+} from '@milaboratories/computable';
+import type { ResourceId, ResourceType } from '@milaboratories/pl-client';
+import { stringifyWithResourceId } from '@milaboratories/pl-client';
+import type {
   AnyLogHandle,
   BlobDriver,
   LocalBlobHandle,
@@ -14,17 +17,19 @@ import {
   ReadyLogHandle,
   RemoteBlobHandle,
   RemoteBlobHandleAndSize,
-  StreamingApiResponse
+  StreamingApiResponse,
 } from '@milaboratories/pl-model-common';
+import type {
+  PlTreeEntry,
+  ResourceInfo,
+  ResourceSnapshot } from '@milaboratories/pl-tree';
 import {
   isPlTreeEntry,
   makeResourceSnapshot,
-  PlTreeEntry,
-  ResourceInfo,
-  ResourceSnapshot,
-  treeEntryToResourceInfo
+  treeEntryToResourceInfo,
 } from '@milaboratories/pl-tree';
-import { CallersCounter, MiLogger, Signer, TaskProcessor } from '@milaboratories/ts-helpers';
+import type { MiLogger, Signer } from '@milaboratories/ts-helpers';
+import { CallersCounter, TaskProcessor } from '@milaboratories/ts-helpers';
 import Denque from 'denque';
 import * as fs from 'fs';
 import { randomUUID } from 'node:crypto';
@@ -34,20 +39,20 @@ import * as path from 'node:path';
 import * as readline from 'node:readline/promises';
 import { Readable, Writable } from 'node:stream';
 import { buffer } from 'node:stream/consumers';
-import { ClientDownload } from '../clients/download';
-import { ClientLogs } from '../clients/logs';
+import type { ClientDownload } from '../clients/download';
+import type { ClientLogs } from '../clients/logs';
 import { DownloadBlobTask, nonRecoverableError } from './download_blob_task';
 import { FilesCache } from './helpers/files_cache';
 import {
   isLocalBlobHandle,
   newLocalHandle,
-  parseLocalHandle
+  parseLocalHandle,
 } from './helpers/download_local_handle';
 import { getSize, OnDemandBlobResourceSnapshot } from './types';
 import {
   isRemoteBlobHandle,
   newRemoteHandle,
-  parseRemoteHandle
+  parseRemoteHandle,
 } from './helpers/download_remote_handle';
 import { getResourceInfoFromLogHandle, newLogHandle } from './helpers/logs_handle';
 import { Updater, WrongResourceTypeError } from './helpers/helpers';
@@ -92,7 +97,7 @@ export class DownloadDriver implements BlobDriver {
     private readonly clientLogs: ClientLogs,
     saveDir: string,
     private readonly signer: Signer,
-    ops: DownloadDriverOps
+    ops: DownloadDriverOps,
   ) {
     this.cache = new FilesCache(ops.cacheSoftSizeBytes);
     this.downloadQueue = new TaskProcessor(this.logger, ops.nConcurrentDownloads);
@@ -100,7 +105,7 @@ export class DownloadDriver implements BlobDriver {
     this.saveDir = path.resolve(saveDir);
   }
 
-  /** Gets a blob by its resource id or downloads a blob and sets it in a cache.*/
+  /** Gets a blob by its resource id or downloads a blob and sets it in a cache. */
   public getDownloadedBlob(
     res: ResourceInfo | PlTreeEntry,
     ctx: ComputableCtx
@@ -110,7 +115,7 @@ export class DownloadDriver implements BlobDriver {
   ): ComputableStableDefined<LocalBlobHandleAndSize>;
   public getDownloadedBlob(
     res: ResourceInfo | PlTreeEntry,
-    ctx?: ComputableCtx
+    ctx?: ComputableCtx,
   ): Computable<LocalBlobHandleAndSize | undefined> | LocalBlobHandleAndSize | undefined {
     if (ctx === undefined) return Computable.make((ctx) => this.getDownloadedBlob(res, ctx));
 
@@ -128,7 +133,7 @@ export class DownloadDriver implements BlobDriver {
   private getDownloadedBlobNoCtx(
     w: Watcher,
     rInfo: ResourceSnapshot,
-    callerId: string
+    callerId: string,
   ): LocalBlobHandleAndSize | undefined {
     validateDownloadableResourceType('getDownloadedBlob', rInfo.type);
 
@@ -139,7 +144,7 @@ export class DownloadDriver implements BlobDriver {
       const newTask = this.setNewDownloadTask(rInfo);
       this.downloadQueue.push({
         fn: () => this.downloadBlob(newTask, callerId),
-        recoverableErrorPredicate: (e) => !nonRecoverableError(e)
+        recoverableErrorPredicate: (e) => !nonRecoverableError(e),
       });
       task = newTask;
     }
@@ -158,7 +163,7 @@ export class DownloadDriver implements BlobDriver {
       this.clientDownload,
       rInfo,
       fPath,
-      newLocalHandle(fPath, this.signer)
+      newLocalHandle(fPath, this.signer),
     );
     this.idToDownload.set(rInfo.id, result);
 
@@ -183,7 +188,7 @@ export class DownloadDriver implements BlobDriver {
   ): RemoteBlobHandleAndSize;
   public getOnDemandBlob(
     res: OnDemandBlobResourceSnapshot | PlTreeEntry,
-    ctx?: ComputableCtx
+    ctx?: ComputableCtx,
   ): ComputableStableDefined<RemoteBlobHandleAndSize> | RemoteBlobHandleAndSize | undefined {
     if (ctx === undefined) return Computable.make((ctx) => this.getOnDemandBlob(res, ctx));
 
@@ -203,7 +208,7 @@ export class DownloadDriver implements BlobDriver {
 
   private getOnDemandBlobNoCtx(
     info: OnDemandBlobResourceSnapshot,
-    callerId: string
+    callerId: string,
   ): RemoteBlobHandleAndSize {
     validateDownloadableResourceType('getOnDemandBlob', info.type);
 
@@ -254,7 +259,7 @@ export class DownloadDriver implements BlobDriver {
   public getLastLogs(
     res: ResourceInfo | PlTreeEntry,
     lines: number,
-    ctx?: ComputableCtx
+    ctx?: ComputableCtx,
   ): Computable<string | undefined> | string | undefined {
     if (ctx == undefined) return Computable.make((ctx) => this.getLastLogs(res, lines, ctx));
 
@@ -273,7 +278,7 @@ export class DownloadDriver implements BlobDriver {
     w: Watcher,
     rInfo: ResourceSnapshot,
     lines: number,
-    callerId: string
+    callerId: string,
   ): string | undefined {
     validateDownloadableResourceType('getLastLogs', rInfo.type);
     const blob = this.getDownloadedBlobNoCtx(w, rInfo, callerId);
@@ -309,7 +314,7 @@ export class DownloadDriver implements BlobDriver {
   public getProgressLog(
     res: ResourceInfo | PlTreeEntry,
     patternToSearch: string,
-    ctx?: ComputableCtx
+    ctx?: ComputableCtx,
   ): Computable<string | undefined> | string | undefined {
     if (ctx == undefined)
       return Computable.make((ctx) => this.getProgressLog(res, patternToSearch, ctx));
@@ -322,7 +327,7 @@ export class DownloadDriver implements BlobDriver {
       ctx.watcher,
       r as ResourceSnapshot,
       patternToSearch,
-      callerId
+      callerId,
     );
     if (result === undefined)
       ctx.markUnstable('either a file was not downloaded or a progress log was not read');
@@ -334,7 +339,7 @@ export class DownloadDriver implements BlobDriver {
     w: Watcher,
     rInfo: ResourceSnapshot,
     patternToSearch: string,
-    callerId: string
+    callerId: string,
   ): string | undefined {
     validateDownloadableResourceType('getProgressLog', rInfo.type);
 
@@ -363,7 +368,7 @@ export class DownloadDriver implements BlobDriver {
   public getLogHandle(res: ResourceInfo | PlTreeEntry, ctx: ComputableCtx): AnyLogHandle;
   public getLogHandle(
     res: ResourceInfo | PlTreeEntry,
-    ctx?: ComputableCtx
+    ctx?: ComputableCtx,
   ): Computable<AnyLogHandle> | AnyLogHandle {
     if (ctx == undefined) return Computable.make((ctx) => this.getLogHandle(res, ctx));
 
@@ -381,13 +386,13 @@ export class DownloadDriver implements BlobDriver {
     handle: ReadyLogHandle,
     lineCount: number,
     offsetBytes?: number, // if 0n, then start from the end.
-    searchStr?: string
+    searchStr?: string,
   ): Promise<StreamingApiResponse> {
     const resp = await this.clientLogs.lastLines(
       getResourceInfoFromLogHandle(handle),
       lineCount,
       BigInt(offsetBytes ?? 0),
-      searchStr
+      searchStr,
     );
 
     return {
@@ -395,7 +400,7 @@ export class DownloadDriver implements BlobDriver {
       shouldUpdateHandle: false,
       data: resp.data,
       size: Number(resp.size),
-      newOffset: Number(resp.newOffset)
+      newOffset: Number(resp.newOffset),
     };
   }
 
@@ -403,13 +408,13 @@ export class DownloadDriver implements BlobDriver {
     handle: ReadyLogHandle,
     lineCount: number,
     offsetBytes?: number,
-    searchStr?: string
+    searchStr?: string,
   ): Promise<StreamingApiResponse> {
     const resp = await this.clientLogs.readText(
       getResourceInfoFromLogHandle(handle),
       lineCount,
       BigInt(offsetBytes ?? 0),
-      searchStr
+      searchStr,
     );
 
     return {
@@ -417,7 +422,7 @@ export class DownloadDriver implements BlobDriver {
       shouldUpdateHandle: false,
       data: resp.data,
       size: Number(resp.size),
-      newOffset: Number(resp.newOffset)
+      newOffset: Number(resp.newOffset),
     };
   }
 
@@ -435,10 +440,10 @@ export class DownloadDriver implements BlobDriver {
 
           this.removeTask(
             task,
-            `the task ${stringifyWithResourceId(task.info())} was removed` +
-              `from cache along with ${stringifyWithResourceId(toDelete.map((d) => d.info()))}`
+            `the task ${stringifyWithResourceId(task.info())} was removed`
+            + `from cache along with ${stringifyWithResourceId(toDelete.map((d) => d.info()))}`,
           );
-        })
+        }),
       );
     } else {
       // The task is still in a downloading queue.
@@ -446,7 +451,7 @@ export class DownloadDriver implements BlobDriver {
       if (deleted) {
         this.removeTask(
           task,
-          `the task ${stringifyWithResourceId(task.info())} was removed from cache`
+          `the task ${stringifyWithResourceId(task.info())} was removed from cache`,
         );
       }
     }
@@ -486,7 +491,7 @@ class OnDemandBlobHolder {
 
   constructor(
     private readonly size: number,
-    private readonly handle: RemoteBlobHandle
+    private readonly handle: RemoteBlobHandle,
   ) {}
 
   public getHandle(): RemoteBlobHandleAndSize {
@@ -511,7 +516,7 @@ class LastLinesGetter {
   constructor(
     private readonly path: string,
     private readonly lines: number,
-    private readonly patternToSearch?: string
+    private readonly patternToSearch?: string,
   ) {
     this.updater = new Updater(async () => this.update());
   }
@@ -526,7 +531,7 @@ class LastLinesGetter {
 
     return {
       log: this.log,
-      error: this.error
+      error: this.error,
     };
   }
 

package/src/drivers/download_blob_task.ts

@@ -1,19 +1,23 @@
-import { ChangeSource, Watcher } from '@milaboratories/computable';
-import { LocalBlobHandle, LocalBlobHandleAndSize } from '@milaboratories/pl-model-common';
-import { ResourceSnapshot } from '@milaboratories/pl-tree';
+import type { Watcher } from '@milaboratories/computable';
+import { ChangeSource } from '@milaboratories/computable';
+import type { LocalBlobHandle, LocalBlobHandleAndSize } from '@milaboratories/pl-model-common';
+import type { ResourceSnapshot } from '@milaboratories/pl-tree';
+import type {
+  ValueOrError,
+  MiLogger,
+} from '@milaboratories/ts-helpers';
 import {
   CallersCounter,
-  ValueOrError,
   ensureDirExists,
   fileExists,
   createPathAtomically,
-  MiLogger
 } from '@milaboratories/ts-helpers';
 import fs from 'node:fs';
 import * as fsp from 'node:fs/promises';
 import * as path from 'node:path';
 import { Writable } from 'node:stream';
-import { ClientDownload, UnknownStorageError, WrongLocalFileUrl } from '../clients/download';
+import type { ClientDownload } from '../clients/download';
+import { UnknownStorageError, WrongLocalFileUrl } from '../clients/download';
 import { NetworkError400 } from '../helpers/download';
 
 /** Downloads a blob. */
@@ -31,7 +35,7 @@ export class DownloadBlobTask {
     private readonly clientDownload: ClientDownload,
     readonly rInfo: ResourceSnapshot,
     readonly path: string,
-    private readonly handle: LocalBlobHandle
+    private readonly handle: LocalBlobHandle,
   ) {}
 
   /** Returns a simple object that describes this task. */
@@ -41,7 +45,7 @@ export class DownloadBlobTask {
       path: this.path,
       done: this.done,
       size: this.size,
-      error: this.error
+      error: this.error,
     };
   }
 
@@ -93,15 +97,15 @@ export class DownloadBlobTask {
   public getBlob():
     | { done: false }
     | {
-        done: true;
-        result: ValueOrError<LocalBlobHandleAndSize>;
-      } {
+      done: true;
+      result: ValueOrError<LocalBlobHandleAndSize>;
+    } {
     if (!this.done) return { done: false };
 
     if (this.error)
       return {
         done: true,
-        result: { ok: false, error: this.error }
+        result: { ok: false, error: this.error },
       };
 
     return {
@@ -110,9 +114,9 @@ export class DownloadBlobTask {
         ok: true,
         value: {
           handle: this.handle,
-          size: this.size
-        }
-      }
+          size: this.size,
+        },
+      },
     };
   }
 
@@ -129,14 +133,14 @@ export class DownloadBlobTask {
 
 export function nonRecoverableError(e: any) {
   return (
-    e instanceof DownloadAborted ||
-    e instanceof NetworkError400 ||
-    e instanceof UnknownStorageError ||
-    e instanceof WrongLocalFileUrl ||
+    e instanceof DownloadAborted
+    || e instanceof NetworkError400
+    || e instanceof UnknownStorageError
+    || e instanceof WrongLocalFileUrl
     // file that we downloads from was moved or deleted.
-    e?.code == 'ENOENT' ||
+    || e?.code == 'ENOENT'
     // A resource was deleted.
-    (e.name == 'RpcError' && (e.code == 'NOT_FOUND' || e.code == 'ABORTED'))
+    || (e.name == 'RpcError' && (e.code == 'NOT_FOUND' || e.code == 'ABORTED'))
   );
 }
 

package/src/drivers/download_blob_url/driver.ts

@@ -0,0 +1,225 @@
+import type { ComputableCtx, Watcher } from '@milaboratories/computable';
+import { Computable } from '@milaboratories/computable';
+import type {
+  MiLogger,
+  Signer } from '@milaboratories/ts-helpers';
+import {
+  TaskProcessor,
+} from '@milaboratories/ts-helpers';
+import { randomUUID } from 'node:crypto';
+import * as path from 'node:path';
+import { FilesCache } from '../helpers/files_cache';
+import type { ResourceId } from '@milaboratories/pl-client';
+import { stringifyWithResourceId } from '@milaboratories/pl-client';
+import type { ArchiveFormat, BlobToURLDriver, FolderURL } from '@milaboratories/pl-model-common';
+import type { DownloadableBlobSnapshot } from './snapshot';
+import { makeDownloadableBlobSnapshot } from './snapshot';
+import type { PlTreeEntry } from '@milaboratories/pl-tree';
+import { isPlTreeEntry } from '@milaboratories/pl-tree';
+import { DownloadAndUnarchiveTask, rmRFDir } from './task';
+import type { ClientDownload } from '../../clients/download';
+import { getPathForFolderURL, isFolderURL } from './url';
+import type { Id } from './driver_id';
+import { newId } from './driver_id';
+import { nonRecoverableError } from '../download_blob_task';
+
+export type DownloadBlobToURLDriverOps = {
+  cacheSoftSizeBytes: number;
+  nConcurrentDownloads: number;
+};
+
+/** Downloads .tar, .tar.gz or zip archives,
+ * extracts them into saveDir and gets a url for it. */
+export class DownloadBlobToURLDriver implements BlobToURLDriver {
+  private idToDownload: Map<Id, DownloadAndUnarchiveTask> = new Map();
+  private downloadQueue: TaskProcessor;
+
+  /** Writes and removes files to a hard drive and holds a counter for every
+   * file that should be kept. */
+  private cache: FilesCache<DownloadAndUnarchiveTask>;
+
+  constructor(
+    private readonly logger: MiLogger,
+    private readonly signer: Signer,
+    private readonly clientDownload: ClientDownload,
+    private readonly saveDir: string,
+    private readonly opts: DownloadBlobToURLDriverOps = {
+      cacheSoftSizeBytes: 50 * 1024 * 1024,
+      nConcurrentDownloads: 50,
+    },
+  ) {
+    this.downloadQueue = new TaskProcessor(this.logger, this.opts.nConcurrentDownloads, {
+      type: 'exponentialWithMaxDelayBackoff',
+      initialDelay: 10000,
+      maxDelay: 30000,
+      backoffMultiplier: 1.5,
+      jitter: 0.5,
+    });
+    this.cache = new FilesCache(this.opts.cacheSoftSizeBytes);
+  }
+
+  public info(): any {
+    return {
+      saveDir: this.saveDir,
+      opts: this.opts,
+      idToDownloadSize: this.idToDownload.size,
+      idToDownloadKeys: this.idToDownload.keys(),
+      idToDownload: Array.from(this.idToDownload.entries()).map(([id, task]) => [id, task.info()]),
+    };
+  }
+
+  /**
+   * @returns full path to the referenced file
+   */
+  getPathForCustomProtocol(url: FolderURL): string {
+    if (isFolderURL(url)) {
+      return getPathForFolderURL(this.signer, url, this.saveDir);
+    }
+
+    throw new Error(`getPathForCustomProtocol: ${url} is invalid`);
+  }
+
+  extractArchiveAndGetURL(
+    res: DownloadableBlobSnapshot | PlTreeEntry,
+    format: ArchiveFormat,
+    ctx: ComputableCtx,
+  ): FolderURL | undefined;
+
+  extractArchiveAndGetURL(
+    res: DownloadableBlobSnapshot | PlTreeEntry,
+    format: ArchiveFormat,
+  ): Computable<FolderURL | undefined>;
+
+  extractArchiveAndGetURL(
+    res: DownloadableBlobSnapshot | PlTreeEntry,
+    format: ArchiveFormat,
+    ctx?: ComputableCtx,
+  ): Computable<FolderURL | undefined> | FolderURL | undefined {
+    // wrap result as computable, if we were not given an existing computable context
+    if (ctx === undefined)
+      return Computable.make((c) => this.extractArchiveAndGetURL(res, format, c));
+
+    const rInfo: DownloadableBlobSnapshot = isPlTreeEntry(res)
+      ? makeDownloadableBlobSnapshot(res, ctx)
+      : res;
+
+    const callerId = randomUUID();
+
+    ctx.addOnDestroy(() => this.releasePath(rInfo.id, format, callerId));
+
+    const result = this.extractArchiveAndGetURLNoCtx(rInfo, format, ctx.watcher, callerId);
+    if (result?.url === undefined)
+      ctx.markUnstable(
+        `a path to the downloaded archive might be undefined. The current result: ${result}`,
+      );
+
+    if (result?.error !== undefined)
+      throw result?.error;
+
+    return result?.url;
+  }
+
+  private extractArchiveAndGetURLNoCtx(
+    rInfo: DownloadableBlobSnapshot,
+    format: ArchiveFormat,
+    w: Watcher,
+    callerId: string,
+  ) {
+    const task = this.idToDownload.get(newId(rInfo.id, format));
+
+    if (task != undefined) {
+      task.attach(w, callerId);
+      return task.getURL();
+    }
+
+    const newTask = this.setNewTask(w, rInfo, format, callerId);
+    this.downloadQueue.push({
+      fn: async () => this.downloadUrl(newTask, callerId),
+      recoverableErrorPredicate: (e) => !nonRecoverableError(e),
+    });
+
+    return newTask.getURL();
+  }
+
+  /** Downloads and extracts a tar archive if it wasn't downloaded yet. */
+  async downloadUrl(task: DownloadAndUnarchiveTask, callerId: string) {
+    await task.download();
+    // Might be undefined if a error happened
+    if (task.getURL()?.url != undefined) this.cache.addCache(task, callerId);
+  }
+
+  /** Removes a directory and aborts a downloading task when all callers
+   * are not interested in it. */
+  async releasePath(id: ResourceId, format: ArchiveFormat, callerId: string): Promise<void> {
+    const task = this.idToDownload.get(newId(id, format));
+    if (task == undefined) return;
+
+    if (this.cache.existsFile(task.path)) {
+      const toDelete = this.cache.removeFile(task.path, callerId);
+
+      await Promise.all(
+        toDelete.map(async (task: DownloadAndUnarchiveTask) => {
+          await rmRFDir(task.path);
+          this.cache.removeCache(task);
+
+          this.removeTask(
+            task,
+            `the task ${stringifyWithResourceId(task.info())} was removed`
+            + `from cache along with ${stringifyWithResourceId(toDelete.map((t) => t.info()))}`,
+          );
+        }),
+      );
+    } 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`,
+        );
+    }
+  }
+
+  /** Removes all files from a hard drive. */
+  async releaseAll() {
+    this.downloadQueue.stop();
+
+    await Promise.all(
+      Array.from(this.idToDownload.entries()).map(async ([_, task]) => {
+        await rmRFDir(task.path);
+        this.cache.removeCache(task);
+
+        this.removeTask(
+          task,
+          `the task ${stringifyWithResourceId(task.info())} was released when the driver was closed`,
+        );
+      }),
+    );
+  }
+
+  private setNewTask(w: Watcher, rInfo: DownloadableBlobSnapshot, format: ArchiveFormat, callerId: string) {
+    const result = new DownloadAndUnarchiveTask(
+      this.logger,
+      this.signer,
+      this.saveDir,
+      this.getFilePath(rInfo.id, format),
+      rInfo,
+      format,
+      this.clientDownload,
+    );
+    result.attach(w, callerId);
+    this.idToDownload.set(newId(rInfo.id, format), result);
+
+    return result;
+  }
+
+  private removeTask(task: DownloadAndUnarchiveTask, reason: string) {
+    task.abort(reason);
+    task.change.markChanged();
+    this.idToDownload.delete(newId(task.rInfo.id, task.format));
+  }
+
+  private getFilePath(id: ResourceId, format: ArchiveFormat): string {
+    return path.join(this.saveDir, `${String(BigInt(id))}_${format}`);
+  }
+}

package/src/drivers/download_blob_url/driver_id.ts

@@ -0,0 +1,11 @@
+import type { ResourceId } from '@milaboratories/pl-client';
+import type { ArchiveFormat } from '@milaboratories/pl-model-common';
+
+/** A key in the driver task queue. */
+export type Id = string;
+
+export function newId(id: ResourceId, format: ArchiveFormat): Id {
+  return `id:${String(BigInt(id))}-${format}`;
+}
+
+// export function

package/src/drivers/download_blob_url/snapshot.ts

@@ -0,0 +1,20 @@
+import type { ComputableCtx } from '@milaboratories/computable';
+import type { InferSnapshot, PlTreeEntry, PlTreeEntryAccessor, PlTreeNodeAccessor } from '@milaboratories/pl-tree';
+import { isPlTreeEntry, isPlTreeEntryAccessor, makeResourceSnapshot, rsSchema } from '@milaboratories/pl-tree';
+
+/** We need only resource type for this driver. */
+export const DownloadableBlobSnapshot = rsSchema({});
+export type DownloadableBlobSnapshot = InferSnapshot<typeof DownloadableBlobSnapshot>;
+
+export function makeDownloadableBlobSnapshot(
+  entryOrAccessor: PlTreeEntry | PlTreeNodeAccessor | PlTreeEntryAccessor,
+  ctx: ComputableCtx,
+): DownloadableBlobSnapshot {
+  const node = isPlTreeEntry(entryOrAccessor)
+    ? ctx.accessor(entryOrAccessor).node()
+    : isPlTreeEntryAccessor(entryOrAccessor)
+      ? entryOrAccessor.node()
+      : entryOrAccessor;
+
+  return makeResourceSnapshot(node, DownloadableBlobSnapshot);
+}