@mountra/mountra-sdk 0.2.0 → 0.4.0

package/dist/index.d.cts

@@ -1,3 +1,129 @@
+/**
+ * Per-download cache behavior, modelled on `RequestInit.cache`:
+ * - `default`: serve a fresh cached file without contacting Mountra; otherwise
+ *   export it and reuse any cached chunks.
+ * - `no-cache`: always export first, but still reuse cached chunks.
+ * - `no-store`: neither read from nor write to the cache.
+ */
+type DownloadCacheMode = "default" | "no-cache" | "no-store";
+interface DownloadCacheOptions {
+    /** Upper bound of cached chunk bytes, shared by all workspaces. Defaults to 512 MiB. */
+    maxBytes?: number;
+    /**
+     * Chunks larger than this are never cached, because a downloaded chunk is
+     * buffered in memory before it is stored. Defaults to 128 MiB and never
+     * exceeds `maxBytes`.
+     */
+    maxChunkBytes?: number;
+    /**
+     * How long a downloaded file may be served from the cache without asking
+     * Mountra whether it changed. Defaults to 5 minutes; 0 always revalidates.
+     */
+    ttlMs?: number;
+    /** Cache storage. Defaults to IndexedDB, or memory when IndexedDB is unavailable. */
+    store?: DownloadCacheStore;
+}
+interface DownloadCacheChunk {
+    index: number;
+    offset: number;
+    size: number;
+    storageKey: string;
+}
+/** The chunk layout of one file. Signed URLs are never cached. */
+interface DownloadCacheFile {
+    path: string;
+    size: number;
+    contentType?: string;
+    chunks: DownloadCacheChunk[];
+    /** When Mountra last confirmed this layout. */
+    cachedAt: number;
+    /** After this time the layout must be confirmed by Mountra again. */
+    expiresAt: number;
+}
+interface DownloadCacheUsage {
+    bytes: number;
+    chunks: number;
+}
+/**
+ * Storage behind the download cache. Every entry is scoped by an opaque
+ * workspace key, so one workspace never observes another workspace's entries.
+ */
+interface DownloadCacheStore {
+    getFile(workspace: string, fileKey: string): Promise<DownloadCacheFile | null>;
+    putFile(workspace: string, fileKey: string, file: DownloadCacheFile): Promise<void>;
+    removeFile(workspace: string, fileKey: string): Promise<void>;
+    /**
+     * Remove every file whose `path` is `path` or below it, keeping the chunks.
+     * Optional: without it, a move or delete through the client clears the
+     * whole workspace instead.
+     */
+    removeFilesUnder?(workspace: string, path: string): Promise<void>;
+    /** Return the chunk bytes and mark the chunk as most recently used. */
+    getChunk(workspace: string, storageKey: string): Promise<Blob | null>;
+    /** Store the chunk bytes, then evict least recently used chunks until at most `maxBytes` remain. */
+    putChunk(workspace: string, storageKey: string, data: Blob, maxBytes: number): Promise<void>;
+    /** Remove every entry, or only the entries of one workspace. */
+    clear(workspace?: string): Promise<void>;
+    usage(workspace?: string): Promise<DownloadCacheUsage>;
+}
+declare class InMemoryDownloadCacheStore implements DownloadCacheStore {
+    private readonly files;
+    /** Map iteration order is the LRU order: the first entry is the least recently used. */
+    private readonly chunks;
+    private bytes;
+    getFile(workspace: string, fileKey: string): Promise<DownloadCacheFile | null>;
+    putFile(workspace: string, fileKey: string, file: DownloadCacheFile): Promise<void>;
+    removeFile(workspace: string, fileKey: string): Promise<void>;
+    removeFilesUnder(workspace: string, path: string): Promise<void>;
+    getChunk(workspace: string, storageKey: string): Promise<Blob | null>;
+    putChunk(workspace: string, storageKey: string, data: Blob, maxBytes: number): Promise<void>;
+    clear(workspace?: string): Promise<void>;
+    usage(workspace?: string): Promise<DownloadCacheUsage>;
+    private removeChunk;
+}
+interface IndexedDBDownloadCacheStoreOptions {
+    /** Use a separate database, for example one per signed-in user. */
+    databaseName?: string;
+}
+declare class IndexedDBDownloadCacheStore implements DownloadCacheStore {
+    private readonly databaseName;
+    private readonly fallback;
+    private databasePromise?;
+    constructor(options?: IndexedDBDownloadCacheStoreOptions);
+    getFile(workspace: string, fileKey: string): Promise<DownloadCacheFile | null>;
+    putFile(workspace: string, fileKey: string, file: DownloadCacheFile): Promise<void>;
+    removeFile(workspace: string, fileKey: string): Promise<void>;
+    removeFilesUnder(workspace: string, path: string): Promise<void>;
+    getChunk(workspace: string, storageKey: string): Promise<Blob | null>;
+    putChunk(workspace: string, storageKey: string, data: Blob, maxBytes: number): Promise<void>;
+    clear(workspace?: string): Promise<void>;
+    usage(workspace?: string): Promise<DownloadCacheUsage>;
+    private openDatabase;
+}
+/** Cache policy of one client. Cache failures degrade to misses and never fail a download. */
+declare class DownloadCache {
+    readonly maxBytes: number;
+    readonly maxChunkBytes: number;
+    readonly ttlMs: number;
+    private readonly store;
+    constructor(options: DownloadCacheOptions);
+    /** Return a file that has not expired together with all of its chunk bytes. */
+    loadFile(workspace: string, fileKey: string): Promise<{
+        file: DownloadCacheFile;
+        chunks: Map<number, Blob>;
+    } | null>;
+    readChunk(workspace: string, chunk: DownloadCacheChunk): Promise<Blob | null>;
+    canStoreChunk(chunk: DownloadCacheChunk): boolean;
+    /** Returns whether the chunk is now cached. */
+    storeChunk(workspace: string, chunk: DownloadCacheChunk, data: Blob): Promise<boolean>;
+    storeFile(workspace: string, fileKey: string, file: Omit<DownloadCacheFile, "cachedAt" | "expiresAt">): Promise<void>;
+    invalidateFiles(workspace: string, fileKeys: string[]): Promise<void>;
+    /** Drop the files at or below `paths`, which a write changed; their chunks stay cached. */
+    invalidatePaths(workspace: string, paths: string[]): Promise<void>;
+    clear(workspace?: string): Promise<void>;
+    usage(workspace?: string): Promise<DownloadCacheUsage>;
+}
+
 interface FileSystemWritableFileStreamLike {
     write(data: Uint8Array | Blob): Promise<void>;
     seek(position: number): Promise<void>;
@@ -67,6 +193,8 @@ interface DownloadFileOptions extends ExportFileOptions {
     onProgress?: (progress: DownloadProgress) => void;
     /** Use a previously selected file handle, primarily for resumeDownload. */
     fileHandle?: FileSystemFileHandleLike;
+    /** How this download uses the client's `downloadCache`. Defaults to `default`. */
+    cache?: DownloadCacheMode;
 }
 interface DownloadResumeOptions {
     signal?: AbortSignal;
@@ -75,9 +203,12 @@ interface DownloadResumeOptions {
     onProgress?: (progress: DownloadProgress) => void;
 }
 interface DownloadResult {
-    export: ExportFileResponse;
+    /** Absent when the file was served from the download cache without contacting Mountra. */
+    export?: ExportFileResponse;
     downloadKey: string;
     downloadedBytes: number;
+    /** Bytes served from the download cache instead of the network. */
+    cachedBytes: number;
     resumed: boolean;
     fileHandle?: FileSystemFileHandleLike;
     blob?: Blob;
@@ -142,6 +273,7 @@ interface DownloadTransport {
     readonly clientSelector: WorkspaceSelector;
     readonly fetchImpl: typeof globalThis.fetch;
     readonly checkpointStore: DownloadCheckpointStore;
+    readonly cache: DownloadCache | null;
     requestJson(path: string, body: unknown, signal?: AbortSignal): Promise<unknown>;
 }
 declare class MountraDownloader {
@@ -153,6 +285,37 @@ declare class MountraDownloader {
     resumeDownload(downloadKey: string, options?: DownloadResumeOptions): Promise<DownloadResult>;
     listResumableDownloads(): Promise<DownloadCheckpoint[]>;
     clearDownloadCheckpoint(downloadKey: string): Promise<void>;
+    /** Drop the cached layout of a file that was just written, so the next download sees the new content. */
+    invalidateCachedFile(selector: WorkspaceSelector, target: {
+        path?: string;
+        ino?: number | string;
+    }): Promise<void>;
+    /** Drop the cached files at or below paths that a delete, move, or copy changed. */
+    invalidateCachedPaths(selector: WorkspaceSelector, paths: string[]): Promise<void>;
+    /**
+     * Cache a file this client just uploaded, so downloading it needs no
+     * network. Falls back to invalidation when any chunk cannot be cached.
+     */
+    cacheUploadedFile(selector: WorkspaceSelector, file: {
+        path: string;
+        ino?: number | string;
+        size: number;
+        contentType?: string;
+        chunks: Array<DownloadCacheChunk & {
+            data: Blob;
+        }>;
+    }, mode?: Exclude<DownloadCacheMode, "no-cache">): Promise<void>;
+    private cachedFileScope;
+    clearCache(selector?: WorkspaceSelector): Promise<void>;
+    cacheUsage(selector?: WorkspaceSelector): Promise<DownloadCacheUsage>;
+    private requireCacheWorkspace;
+    /** Fall back to the client workspace only when the request names none, as uploads do. */
+    private resolveRequest;
+    private exportRequest;
+    private cacheScope;
+    /** A plan that needs no network at all, when the cached layout is fresh and every chunk is cached. */
+    private loadCachedPlan;
+    private planExport;
     private pickSaveFile;
     private ensureWritePermission;
     private downloadResolved;
@@ -197,6 +360,197 @@ declare class MountraFile {
     resume(options?: MountraFileResumeOptions): Promise<DownloadResult>;
 }
 
+type MetadataCacheKind = "list" | "tree";
+/** A cached `list` result: the entries of one directory. */
+interface MetadataListRecord {
+    kind: "list";
+    path: string;
+    entries: MountraFileEntry[];
+    /**
+     * When the request that returned this result was sent. Writes through this
+     * client and overlapping fetches may have updated the record since.
+     */
+    fetchedAt: number;
+}
+/** A cached `tree` result: one directory and its complete subtree. */
+interface MetadataTreeRecord {
+    kind: "tree";
+    path: string;
+    root: MountraFileTreeNode;
+    /** See `MetadataListRecord.fetchedAt`. */
+    fetchedAt: number;
+}
+type MetadataCacheRecord = MetadataListRecord | MetadataTreeRecord;
+interface MetadataCacheBatch {
+    put: MetadataCacheRecord[];
+    remove: Array<{
+        kind: MetadataCacheKind;
+        path: string;
+    }>;
+}
+interface MetadataCacheOptions {
+    /**
+     * Upper bound of cached `list` and `tree` results, shared by all
+     * workspaces. A tree counts as one result however large it is. Defaults to
+     * 1000; the least recently refreshed results are evicted first.
+     */
+    maxEntries?: number;
+    /** Cache storage. Defaults to IndexedDB, or memory when IndexedDB is unavailable. */
+    store?: MetadataCacheStore;
+}
+/**
+ * Storage behind the metadata cache. A record is identified by an opaque
+ * workspace key together with its `kind` and `path`, so one workspace never
+ * observes another workspace's records.
+ */
+interface MetadataCacheStore {
+    get(workspace: string, kind: MetadataCacheKind, path: string): Promise<MetadataCacheRecord | null>;
+    /** The records stored at `path` or at any path below it, of one kind or of both. */
+    getSubtree(workspace: string, path: string, kind?: MetadataCacheKind): Promise<MetadataCacheRecord[]>;
+    /** Apply the batch atomically, then evict the least recently written records until at most `maxEntries` remain. */
+    write(workspace: string, batch: MetadataCacheBatch, maxEntries: number): Promise<void>;
+    /** Remove every record, or only the records of one workspace. */
+    clear(workspace?: string): Promise<void>;
+}
+declare class InMemoryMetadataCacheStore implements MetadataCacheStore {
+    /** Map iteration order is the eviction order: the first entry was written least recently. */
+    private readonly records;
+    get(workspace: string, kind: MetadataCacheKind, path: string): Promise<MetadataCacheRecord | null>;
+    getSubtree(workspace: string, path: string, kind?: MetadataCacheKind): Promise<MetadataCacheRecord[]>;
+    write(workspace: string, batch: MetadataCacheBatch, maxEntries: number): Promise<void>;
+    clear(workspace?: string): Promise<void>;
+}
+interface IndexedDBMetadataCacheStoreOptions {
+    /** Use a separate database, for example one per signed-in user. */
+    databaseName?: string;
+}
+/** Records are keyed `[workspace, kind, path]`, so a subtree of one kind is one key range. */
+declare class IndexedDBMetadataCacheStore implements MetadataCacheStore {
+    private readonly databaseName;
+    private readonly fallback;
+    private databasePromise?;
+    constructor(options?: IndexedDBMetadataCacheStoreOptions);
+    get(workspace: string, kind: MetadataCacheKind, path: string): Promise<MetadataCacheRecord | null>;
+    getSubtree(workspace: string, path: string, kind?: MetadataCacheKind): Promise<MetadataCacheRecord[]>;
+    write(workspace: string, batch: MetadataCacheBatch, maxEntries: number): Promise<void>;
+    clear(workspace?: string): Promise<void>;
+    private openDatabase;
+}
+
+/** One entry of a directory listing. */
+interface MountraFileEntry {
+    name: string;
+    /** Absolute path in the workspace. */
+    path: string;
+    ino: number;
+    isDirectory: boolean;
+    size: number;
+    mtimeMs: number;
+    atimeMs: number;
+    uid?: number;
+    gid?: number;
+    uidDisplayName?: string;
+    uidUsername?: string;
+    uidSubjectId?: string;
+    uidSubjectType?: string;
+    gidDisplayName?: string;
+    gidUsername?: string;
+    gidSubjectId?: string;
+    gidSubjectType?: string;
+}
+/** A node of a file tree. A directory node holds its complete subtree. */
+interface MountraFileTreeNode {
+    name: string;
+    /** Absolute path in the workspace. */
+    path: string;
+    ino: number;
+    isDirectory: boolean;
+    size: number;
+    mtimeMs: number;
+    uid?: number;
+    gid?: number;
+    uidSubjectId?: string;
+    uidSubjectType?: string;
+    gidSubjectId?: string;
+    gidSubjectType?: string;
+    children: MountraFileTreeNode[];
+}
+/**
+ * How a metadata read uses the client's `metadataCache`:
+ * - `sync`: wait for Mountra and return its result.
+ * - `async`: return the cached result at once and refresh it in the
+ *   background. Without a cached result, wait for Mountra as `sync` does.
+ *
+ * Either way, a result fetched from Mountra is cached before it is returned.
+ */
+type MetadataReadMode = "sync" | "async";
+/** `cache` when the result was served from the metadata cache, `remote` when Mountra just returned it. */
+type MetadataSource = "cache" | "remote";
+interface MetadataReadOptions<T> extends WorkspaceSelector {
+    /** The directory to read. Defaults to `/`. */
+    path?: string;
+    /** Defaults to `sync`. */
+    mode?: MetadataReadMode;
+    /**
+     * `async` only: receives the refreshed result of a cached result that was
+     * returned, when the two differ.
+     */
+    onUpdate?: (result: T) => void;
+    /** `async` only: receives the error of a failed background refresh. */
+    onError?: (error: unknown) => void;
+    /** Also cancels the background refresh; no callback runs once it has aborted. */
+    signal?: AbortSignal;
+}
+interface ListResult {
+    path: string;
+    /** Directories first, then by name. */
+    entries: MountraFileEntry[];
+    source: MetadataSource;
+    /**
+     * When the request that returned this result was sent. A cached result
+     * also reflects writes made through this client since then.
+     */
+    fetchedAt: number;
+}
+interface TreeResult {
+    path: string;
+    root: MountraFileTreeNode;
+    source: MetadataSource;
+    /** See `ListResult.fetchedAt`. */
+    fetchedAt: number;
+}
+type ListOptions = MetadataReadOptions<ListResult>;
+type TreeOptions = MetadataReadOptions<TreeResult>;
+interface MkdirOptions extends WorkspaceSelector {
+    /** The directory to create. Its parent must exist. */
+    path: string;
+    signal?: AbortSignal;
+}
+interface RenameOptions extends WorkspaceSelector {
+    fromPath: string;
+    /** The new name within the same directory. */
+    toName: string;
+    signal?: AbortSignal;
+}
+interface MoveOptions extends WorkspaceSelector {
+    fromPath: string;
+    /** The complete destination path, which must not exist yet. */
+    toPath: string;
+    signal?: AbortSignal;
+}
+/** Copies one file; Mountra does not copy directories. */
+type CopyOptions = MoveOptions;
+interface DeleteOptions extends WorkspaceSelector {
+    /** A file, or an empty directory. */
+    path: string;
+    signal?: AbortSignal;
+}
+interface FileOperationResult {
+    /** The path of the created, renamed, moved, or copied entry. */
+    path: string;
+    ino: number;
+}
+
 type ChunkMethod = "none" | "fix";
 type WorkspaceId = number | string;
 declare const JUMBO_CHUNK_THRESHOLD_BYTES: number;
@@ -225,10 +579,25 @@ interface MountraClientOptions extends WorkspaceSelector {
     jumboPartSize?: number;
     /** IndexedDB-backed download checkpoint store. */
     downloadCheckpointStore?: DownloadCheckpointStore;
+    /**
+     * Cache downloaded chunks locally, per workspace, in IndexedDB. Disabled
+     * unless set; pass `{}` for the defaults.
+     */
+    downloadCache?: DownloadCacheOptions;
+    /**
+     * Cache `list` and `tree` results locally, per workspace, in IndexedDB, so
+     * reads with `mode: "async"` return at once. Disabled unless set; pass `{}`
+     * for the defaults.
+     */
+    metadataCache?: MetadataCacheOptions;
 }
 interface UploadFileOptions extends WorkspaceSelector {
     path: string;
-    /** Number of logical chunks. Defaults to 1. */
+    /**
+     * Maximum number of fixed-size chunks. Defaults to 1. Each chunk is
+     * `ceil(size / chunkCount)` bytes except the last, so an uneven split may
+     * produce fewer chunks.
+     */
     chunkCount?: number;
     contentType?: string;
     nameConflictStrategy?: "overwrite" | "keep_both";
@@ -236,10 +605,17 @@ interface UploadFileOptions extends WorkspaceSelector {
     onProgress?: (progress: MountraProgress) => void;
     /** Persist this serializable context before the first chunk is uploaded. */
     onSessionPrepared?: (context: UploadSessionContext) => void | Promise<void>;
+    /**
+     * With the client's `downloadCache`, an uploaded file is cached by default so
+     * downloading it needs no network. `no-store` only invalidates its old entry.
+     */
+    cache?: "default" | "no-store";
 }
 interface UploadResumeOptions extends WorkspaceSelector {
     signal?: AbortSignal;
     onProgress?: (progress: MountraProgress) => void;
+    /** See `UploadFileOptions.cache`. */
+    cache?: "default" | "no-store";
 }
 interface MountraProgress {
     phase: "uploading" | "finishing";
@@ -426,16 +802,6 @@ interface PreparedUpload {
     contentHash: string;
     context: UploadSessionContext;
 }
-declare class MountraApiError extends Error {
-    readonly status: number;
-    readonly code?: string;
-    readonly body?: unknown;
-    constructor(message: string, input: {
-        status: number;
-        code?: string;
-        body?: unknown;
-    });
-}
 declare class InMemoryJumboChunkCheckpointStore implements JumboChunkCheckpointStore {
     private readonly records;
     load(key: string): Promise<JumboChunkCheckpoint | null>;
@@ -485,6 +851,7 @@ declare class MountraClient {
     private readonly jumboChunkCheckpointStore;
     private readonly jumboPartSize;
     private readonly downloader;
+    private readonly metadata;
     constructor(options: MountraClientOptions);
     exportFile(options: ExportFileOptions): Promise<ExportFileResponse>;
     downloadFile(options: DownloadFileOptions): Promise<DownloadResult>;
@@ -492,6 +859,20 @@ declare class MountraClient {
     resumeDownload(downloadKey: string, options?: DownloadResumeOptions): Promise<DownloadResult>;
     listResumableDownloads(): Promise<DownloadCheckpoint[]>;
     clearDownloadCheckpoint(downloadKey: string): Promise<void>;
+    /** Clear the download cache of one workspace, or of every workspace when none is given. */
+    clearDownloadCache(selector?: WorkspaceSelector): Promise<void>;
+    getDownloadCacheUsage(selector?: WorkspaceSelector): Promise<DownloadCacheUsage>;
+    /** List the entries of a directory. See `MetadataReadMode` for how `mode` uses the metadata cache. */
+    list(options?: ListOptions): Promise<ListResult>;
+    /** Return a directory with its complete subtree. See `MetadataReadMode` for how `mode` uses the metadata cache. */
+    tree(options?: TreeOptions): Promise<TreeResult>;
+    mkdir(options: MkdirOptions): Promise<FileOperationResult>;
+    rename(options: RenameOptions): Promise<FileOperationResult>;
+    move(options: MoveOptions): Promise<FileOperationResult>;
+    copy(options: CopyOptions): Promise<FileOperationResult>;
+    delete(options: DeleteOptions): Promise<void>;
+    /** Clear the metadata cache of one workspace, or of every workspace when none is given. */
+    clearMetadataCache(selector?: WorkspaceSelector): Promise<void>;
     /** Create a stable resource object for one file in this or another workspace. */
     file(locator: MountraFileLocator): MountraFile;
     prepareUpload(file: Blob, options: UploadFileOptions): Promise<PreparedUpload>;
@@ -511,9 +892,23 @@ declare class MountraClient {
     private isCompatibleJumboCheckpoint;
     private assertUploadContext;
     finishUpload(uploadId: string, selector?: WorkspaceSelector): Promise<UploadResult>;
+    /** Same workspace resolution as `getWorkspaceBody`, so the cache key matches what Mountra used. */
+    private cacheWorkspace;
     private endpoint;
     private requestJson;
 }
 declare function createMountraClient(options: MountraClientOptions): MountraClient;
 
-export { type AccessToken, type ChunkMethod, DEFAULT_S3_MULTIPART_PART_SIZE_BYTES, type DownloadCheckpoint, type DownloadCheckpointChunk, type DownloadCheckpointRequest, type DownloadCheckpointStore, type DownloadFileOptions, DownloadHttpError, type DownloadProgress, type DownloadResult, type DownloadResumeOptions, type ExportFileChunk, type ExportFileOptions, type ExportFileResponse, type FileChunk, type FileSystemFileHandleLike, type FileSystemWritableFileStreamLike, type FinishUploadResponse, InMemoryDownloadCheckpointStore, InMemoryJumboChunkCheckpointStore, IndexedDBDownloadCheckpointStore, JUMBO_CHUNK_THRESHOLD_BYTES, type JumboChunkCheckpoint, type JumboChunkCheckpointStore, type JumboChunkCompleteInput, type JumboChunkCreateInput, type JumboChunkUploadPartInput, type JumboChunkUploader, LocalStorageJumboChunkCheckpointStore, MAX_S3_MULTIPART_PARTS, MIN_S3_MULTIPART_PART_SIZE_BYTES, MountraApiError, MountraClient, type MountraClientOptions, MountraDownloader, MountraFile, type MountraFileDownloadOptions, type MountraFileExportOptions, type MountraFileLocator, type MountraFileResumeOptions, type MountraProgress, MountraClient as MountraSDK, type NormalizedMountraFileLocator, type PrepareUploadResponse, type PreparedUpload, type S3MultipartClient, type S3MultipartPart, S3MultipartUploader, type UploadFileOptions, type UploadResult, type UploadResumeOptions, type UploadSessionChunkContext, type UploadSessionContext, type UploadStatusChunk, type UploadStatusResponse, type UploadTarget, type WorkspaceId, type WorkspaceSelector, createMountraClient, isJumboChunk, sha256Hex, splitFileIntoChunks };
+/** An HTTP error returned by Mountra, or by a signed upload URL. */
+declare class MountraApiError extends Error {
+    readonly status: number;
+    readonly code?: string;
+    readonly body?: unknown;
+    constructor(message: string, input: {
+        status: number;
+        code?: string;
+        body?: unknown;
+    });
+}
+
+export { type AccessToken, type ChunkMethod, type CopyOptions, DEFAULT_S3_MULTIPART_PART_SIZE_BYTES, type DeleteOptions, type DownloadCacheChunk, type DownloadCacheFile, type DownloadCacheMode, type DownloadCacheOptions, type DownloadCacheStore, type DownloadCacheUsage, type DownloadCheckpoint, type DownloadCheckpointChunk, type DownloadCheckpointRequest, type DownloadCheckpointStore, type DownloadFileOptions, DownloadHttpError, type DownloadProgress, type DownloadResult, type DownloadResumeOptions, type ExportFileChunk, type ExportFileOptions, type ExportFileResponse, type FileChunk, type FileOperationResult, type FileSystemFileHandleLike, type FileSystemWritableFileStreamLike, type FinishUploadResponse, InMemoryDownloadCacheStore, InMemoryDownloadCheckpointStore, InMemoryJumboChunkCheckpointStore, InMemoryMetadataCacheStore, IndexedDBDownloadCacheStore, type IndexedDBDownloadCacheStoreOptions, IndexedDBDownloadCheckpointStore, IndexedDBMetadataCacheStore, type IndexedDBMetadataCacheStoreOptions, JUMBO_CHUNK_THRESHOLD_BYTES, type JumboChunkCheckpoint, type JumboChunkCheckpointStore, type JumboChunkCompleteInput, type JumboChunkCreateInput, type JumboChunkUploadPartInput, type JumboChunkUploader, type ListOptions, type ListResult, LocalStorageJumboChunkCheckpointStore, MAX_S3_MULTIPART_PARTS, MIN_S3_MULTIPART_PART_SIZE_BYTES, type MetadataCacheBatch, type MetadataCacheKind, type MetadataCacheOptions, type MetadataCacheRecord, type MetadataCacheStore, type MetadataListRecord, type MetadataReadMode, type MetadataReadOptions, type MetadataSource, type MetadataTreeRecord, type MkdirOptions, MountraApiError, MountraClient, type MountraClientOptions, MountraDownloader, MountraFile, type MountraFileDownloadOptions, type MountraFileEntry, type MountraFileExportOptions, type MountraFileLocator, type MountraFileResumeOptions, type MountraFileTreeNode, type MountraProgress, MountraClient as MountraSDK, type MoveOptions, type NormalizedMountraFileLocator, type PrepareUploadResponse, type PreparedUpload, type RenameOptions, type S3MultipartClient, type S3MultipartPart, S3MultipartUploader, type TreeOptions, type TreeResult, type UploadFileOptions, type UploadResult, type UploadResumeOptions, type UploadSessionChunkContext, type UploadSessionContext, type UploadStatusChunk, type UploadStatusResponse, type UploadTarget, type WorkspaceId, type WorkspaceSelector, createMountraClient, isJumboChunk, sha256Hex, splitFileIntoChunks };