sliftutils 1.7.4 → 1.7.6

package/index.d.ts

@@ -1717,6 +1717,7 @@ declare module "sliftutils/storage/DiskCollection" {
             writeDelay?: number | undefined;
             cbor?: boolean | undefined;
             noPrompt?: boolean | undefined;
+            resyncFromDisk?: boolean | undefined;
             freeze?: "deep" | "shallow" | undefined;
             beforeWrite?: ((update: {
                 newValue: T;
@@ -1878,6 +1879,7 @@ declare module "sliftutils/storage/FileFolderAPI" {
         [Symbol.asyncIterator](): AsyncIterableIterator<[string, FileWrapper | DirectoryWrapper]>;
     };
     export declare function setFileAPIKey(key: string): void;
+    export declare function setStorageRootOverride(handle: FileSystemDirectoryHandle | undefined): void;
     export declare class NodeJSFileHandleWrapper implements FileWrapper {
         private filePath;
         constructor(filePath: string);
@@ -1967,6 +1969,47 @@ declare module "sliftutils/storage/FileFolderAPI" {
 
 }
 
+declare module "sliftutils/storage/IArchives" {
+    /// <reference types="node" />
+    /// <reference types="node" />
+    export type ArchiveFileInfo = {
+        path: string;
+        createTime: number;
+        size: number;
+    };
+    export interface IArchives {
+        getDebugName(): string;
+        get(fileName: string, config?: {
+            range?: {
+                start: number;
+                end: number;
+            };
+        }): Promise<Buffer | undefined>;
+        set(fileName: string, data: Buffer): Promise<void>;
+        del(fileName: string): Promise<void>;
+        /** Streams a file too large to hold in memory. getNextData returns undefined when done. */
+        setLargeFile(config: {
+            path: string;
+            getNextData(): Promise<Buffer | undefined>;
+        }): Promise<void>;
+        getInfo(fileName: string): Promise<{
+            writeTime: number;
+            size: number;
+        } | undefined>;
+        find(prefix: string, config?: {
+            shallow?: boolean;
+            type: "files" | "folders";
+        }): Promise<string[]>;
+        findInfo(prefix: string, config?: {
+            shallow?: boolean;
+            type: "files" | "folders";
+        }): Promise<ArchiveFileInfo[]>;
+        /** Only works for public buckets (private buckets are API-access only). */
+        getURL(path: string): Promise<string>;
+    }
+
+}
+
 declare module "sliftutils/storage/IStorage" {
     /// <reference types="node" />
     /// <reference types="node" />
@@ -2177,12 +2220,13 @@ declare module "sliftutils/storage/TransactionStorage" {
         private rawStorage;
         private debugName;
         private writeDelay;
+        private resyncFromDisk;
         cache: Map<string, TransactionEntry>;
         private diskFiles;
         private currentChunk;
         private entryCount;
         private static allStorage;
-        constructor(rawStorage: IStorageRaw, debugName: string, writeDelay?: number);
+        constructor(rawStorage: IStorageRaw, debugName: string, writeDelay?: number, resyncFromDisk?: boolean);
         static compressAll(): Promise<void>;
         private resyncCallbacks;
         watchResync(callback: () => void): void;
@@ -2222,7 +2266,8 @@ declare module "sliftutils/storage/TransactionStorage" {
 declare module "sliftutils/storage/backblaze" {
     /// <reference types="node" />
     /// <reference types="node" />
-    export declare class ArchivesBackblaze {
+    import { IArchives } from "./IArchives";
+    export declare class ArchivesBackblaze implements IArchives {
         private config;
         constructor(config: {
             bucketName: string;
@@ -2525,6 +2570,240 @@ declare module "sliftutils/storage/remoteFileStorage" {
 
 }
 
+declare module "sliftutils/storage/remoteStorage/ArchivesRemote" {
+    /// <reference types="node" />
+    /// <reference types="node" />
+    import { IArchives, ArchiveFileInfo } from "../IArchives";
+    export type ArchivesRemoteConfig = {
+        address: string;
+        port: number;
+        account: string;
+        bucketName: string;
+        public?: boolean;
+        fast?: boolean;
+        writeDelay?: number;
+    };
+    export declare function buildPublicFileURL(config: {
+        address: string;
+        port: number;
+        account: string;
+        bucketName: string;
+        path: string;
+    }): string;
+    export declare function authenticateStorage(config: {
+        address: string;
+        port: number;
+        nodeId: string;
+    }): Promise<{
+        machineId: string;
+        ip: string;
+    }>;
+    export declare class ArchivesRemote implements IArchives {
+        private config;
+        constructor(config: ArchivesRemoteConfig);
+        private nodeId;
+        private controller;
+        private setupDone;
+        private lastDeniedLog;
+        getDebugName(): string;
+        private authenticate;
+        private callAuthed;
+        waitingForAccess(): Promise<string | undefined>;
+        private onAccessDenied;
+        private ensureSetup;
+        private call;
+        get(fileName: string, config?: {
+            range?: {
+                start: number;
+                end: number;
+            };
+        }): Promise<Buffer | undefined>;
+        set(fileName: string, data: Buffer): Promise<void>;
+        del(fileName: string): Promise<void>;
+        getInfo(fileName: string): Promise<{
+            writeTime: number;
+            size: number;
+        } | undefined>;
+        findInfo(prefix: string, config?: {
+            shallow?: boolean;
+            type: "files" | "folders";
+        }): Promise<ArchiveFileInfo[]>;
+        find(prefix: string, config?: {
+            shallow?: boolean;
+            type: "files" | "folders";
+        }): Promise<string[]>;
+        setLargeFile(config: {
+            path: string;
+            getNextData(): Promise<Buffer | undefined>;
+        }): Promise<void>;
+        getURL(path: string): Promise<string>;
+    }
+
+}
+
+declare module "sliftutils/storage/remoteStorage/accessPage" {
+    export {};
+
+}
+
+declare module "sliftutils/storage/remoteStorage/blobStore" {
+    /// <reference types="node" />
+    /// <reference types="node" />
+    import { ArchiveFileInfo } from "../IArchives";
+    export declare const DEFAULT_FAST_WRITE_DELAY: number;
+    export type WriteConfig = {
+        fast?: boolean;
+        writeDelay?: number;
+    };
+    export declare class BlobStore {
+        private folder;
+        constructor(folder: string);
+        private memCache;
+        private overlay;
+        private writeQueue;
+        private openBlobs;
+        private largeUploads;
+        private nextLargeUploadId;
+        private currentBlobNumber;
+        private currentBlobOffset;
+        private currentBlobFd;
+        private index;
+        private deadBytes;
+        private blobsDir;
+        init: {
+            (): Promise<void>;
+            reset(): void;
+            set(newValue: Promise<void>): void;
+        };
+        private blobName;
+        private blobPath;
+        private getBlobHandle;
+        private closeBlobHandle;
+        private addDeadBytes;
+        private appendData;
+        private setIndexEntry;
+        set(key: string, data: Buffer, config?: WriteConfig): Promise<void>;
+        del(key: string, config?: WriteConfig): Promise<void>;
+        get(key: string, range?: {
+            start: number;
+            end: number;
+        }): Promise<Buffer | undefined>;
+        getInfo(key: string): Promise<{
+            writeTime: number;
+            size: number;
+        } | undefined>;
+        findInfo(prefix: string, config?: {
+            shallow?: boolean;
+            type?: "files" | "folders";
+        }): Promise<ArchiveFileInfo[]>;
+        startLargeUpload(): Promise<string>;
+        appendLargeUpload(id: string, data: Buffer): Promise<void>;
+        finishLargeUpload(id: string, key: string): Promise<void>;
+        cancelLargeUpload(id: string): Promise<void>;
+        private flushOverlay;
+        private compact;
+    }
+
+}
+
+declare module "sliftutils/storage/remoteStorage/storageController" {
+    /// <reference types="node" />
+    /// <reference types="node" />
+    import { ArchiveFileInfo } from "../IArchives";
+    import type { BlobStore } from "./blobStore";
+    import type { IStorage } from "../IStorage";
+    export declare const REMOTE_STORAGE_CLASS_GUID = "RemoteStorageController-b7e42a91";
+    export declare const STORAGE_AUTH_PURPOSE = "remoteStorage-auth-1";
+    export declare const STORAGE_NOT_AUTHENTICATED = "REMOTE_STORAGE_NOT_AUTHENTICATED_cf2f7b1e";
+    export declare const STORAGE_ACCESS_DENIED = "REMOTE_STORAGE_ACCESS_DENIED_9d81a4c0";
+    export type AuthToken = {
+        certPem: string;
+        time: number;
+        signature: string;
+    };
+    export type AccessRequest = {
+        requestId: string;
+        account: string;
+        machineId: string;
+        ip: string;
+        time: number;
+    };
+    export type TrustRecord = {
+        account: string;
+        machineId: string;
+        ip: string;
+        time: number;
+    };
+    export type BucketConfig = {
+        public?: boolean;
+        fast?: boolean;
+        writeDelay?: number;
+    };
+    export type AccessState = {
+        machineId: string;
+        ip: string;
+        hasAccess: boolean;
+        listAccessCommand: string;
+        grantAccessCommand?: string;
+        machines?: (AccessRequest & {
+            trusted: boolean;
+        })[];
+    };
+    export type StorageServerState = {
+        domain: string;
+        port: number;
+        rootDomain: string;
+        sshTarget: string;
+        serverCommand: string;
+        blobStore: BlobStore;
+        trust: IStorage<TrustRecord>;
+        requests: IStorage<AccessRequest[]>;
+        buckets: IStorage<BucketConfig>;
+    };
+    export declare function setStorageServerState(state: StorageServerState): void;
+    export declare const RemoteStorageController: import("socket-function/SocketFunctionTypes").SocketRegistered<{
+        authenticate: (token: AuthToken) => Promise<{
+            machineId: string;
+            ip: string;
+        }>;
+        requestAccess: (account: string) => Promise<{
+            machineId: string;
+            ip: string;
+            requestId: string;
+            grantAccessCommand: string;
+        }>;
+        getAccessState: (account: string) => Promise<AccessState>;
+        adminListRequests: (ip: string) => Promise<AccessRequest[]>;
+        adminGrantAccess: (requestId: string) => Promise<TrustRecord>;
+        ensureBucket: (account: string, bucketName: string, config: BucketConfig) => Promise<void>;
+        get: (account: string, bucketName: string, path: string, range?: {
+            start: number;
+            end: number;
+        }) => Promise<Buffer | undefined>;
+        set: (account: string, bucketName: string, path: string, data: Buffer) => Promise<void>;
+        del: (account: string, bucketName: string, path: string) => Promise<void>;
+        getInfo: (account: string, bucketName: string, path: string) => Promise<{
+            writeTime: number;
+            size: number;
+        } | undefined>;
+        findInfo: (account: string, bucketName: string, prefix: string, config?: {
+            shallow?: boolean;
+            type?: "files" | "folders";
+        }) => Promise<ArchiveFileInfo[]>;
+        startLargeFile: (account: string, bucketName: string, path: string) => Promise<string>;
+        uploadPart: (uploadId: string, data: Buffer) => Promise<void>;
+        finishLargeFile: (uploadId: string) => Promise<void>;
+        cancelLargeFile: (uploadId: string) => Promise<void>;
+        getPublicFile: (account: string, bucketName: string, path: string) => Promise<Buffer>;
+    }>;
+
+}
+
+declare module "sliftutils/storage/remoteStorage/storageServer" {
+    import "./accessPage";
+
+}
+
 declare module "sliftutils/storage/storage" {
 
 

package/misc/https/persistentLocalStorage.ts

@@ -1,3 +1,5 @@
+module.allowclient = true;
+
 import { isNode } from "socket-function/src/misc";
 import fs from "fs";
 import os from "os";

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "sliftutils",
-    "version": "1.7.4",
+    "version": "1.7.6",
     "main": "index.js",
     "license": "MIT",
     "files": [

package/render-utils/Input.tsx

@@ -1,3 +1,5 @@
+module.allowclient = true;
+
 import preact from "preact";
 import { css } from "typesafecss";
 import { observer } from "./observer";

package/render-utils/InputLabel.tsx

@@ -1,3 +1,5 @@
+module.allowclient = true;
+
 import preact from "preact";
 import { Input } from "./Input";
 import { css } from "typesafecss";

package/render-utils/colors.tsx

@@ -1,3 +1,5 @@
+module.allowclient = true;
+
 import { css } from "typesafecss";
 
 export const redButton = css.hsl(0, 75, 50).bord(1, "hsl(0, 75%, 75%)").background("hsl(0, 75%, 75%)", "hover") as string;

package/storage/BulkDatabase2/syncClient.ts

@@ -1,10 +1,9 @@
-import { isNode } from "typesafecss";
-
 // Browser-side cross-tab write sync for BulkDatabase2, over BroadcastChannel (one channel per
-// collection, same-origin tabs). It does NOT persist anything — each tab writes to disk itself; this
-// just relays live writes to other open tabs and, when a tab starts up, asks peers for writes they've
-// made recently that may not be on disk yet. No-op in Node / where BroadcastChannel is unavailable, so
-// BulkDatabase2 can call these unconditionally. This is an optional feature, so there is no fallback.
+// collection, same-origin tabs and workers). It does NOT persist anything — each side writes to disk
+// itself; this just relays live writes to other open tabs/workers and, when one starts up, asks peers
+// for writes they've made recently that may not be on disk yet. No-op in Node / where
+// BroadcastChannel is unavailable, so BulkDatabase2 can call these unconditionally. This is an
+// optional feature, so there is no fallback.
 
 export type RemoteWrite = { key: string; time: number; deleted?: boolean; value?: unknown };
 
@@ -24,7 +23,11 @@ type Channel = {
 const channels = new Map<string, Channel>();
 
 export function isSyncSupported(): boolean {
-    return !isNode() && typeof BroadcastChannel !== "undefined";
+    // window (main-thread browser) or WorkerGlobalScope (Web/Service/Shared worker) — but not Node
+    // (typesafecss's isNode is `typeof window === "undefined"`, which misclassifies workers)
+    let isBrowserOrWorker = typeof window !== "undefined"
+        || "WorkerGlobalScope" in globalThis;
+    return isBrowserOrWorker && typeof BroadcastChannel !== "undefined";
 }
 
 function pruneRecent(channel: Channel) {

package/storage/DiskCollection.d.ts

@@ -12,6 +12,7 @@ export declare class DiskCollection<T> implements IStorageSync<T> {
         writeDelay?: number | undefined;
         cbor?: boolean | undefined;
         noPrompt?: boolean | undefined;
+        resyncFromDisk?: boolean | undefined;
         freeze?: "deep" | "shallow" | undefined;
         beforeWrite?: ((update: {
             newValue: T;

package/storage/DiskCollection.ts

@@ -34,6 +34,8 @@ export class DiskCollection<T> implements IStorageSync<T> {
             writeDelay?: number;
             cbor?: boolean;
             noPrompt?: boolean;
+            // Poll disk and reload when another process/tab writes to this collection. Off by default.
+            resyncFromDisk?: boolean;
             freeze?: "shallow" | "deep";
             // May mutate newValue in order to change what will be written
             beforeWrite?: (update: { newValue: T; key: string; collection: DiskCollection<T> }) => void;
@@ -52,7 +54,7 @@ export class DiskCollection<T> implements IStorageSync<T> {
             let collections = await fileStorage.folder.getStorage("collections");
             curCollection = await collections.folder.getStorage(this.collectionName);
         }
-        let baseStorage = new TransactionStorage(curCollection, this.collectionName, this.config?.writeDelay);
+        let baseStorage = new TransactionStorage(curCollection, this.collectionName, this.config?.writeDelay, this.config?.resyncFromDisk);
         this.transactionStorage = baseStorage;
         return this.config?.cbor ? new CBORStorage<T>(baseStorage) : new JSONStorage<T>(baseStorage);
     }

package/storage/FileFolderAPI.d.ts

@@ -66,6 +66,7 @@ export type DirectoryWrapper = {
     [Symbol.asyncIterator](): AsyncIterableIterator<[string, FileWrapper | DirectoryWrapper]>;
 };
 export declare function setFileAPIKey(key: string): void;
+export declare function setStorageRootOverride(handle: FileSystemDirectoryHandle | undefined): void;
 export declare class NodeJSFileHandleWrapper implements FileWrapper {
     private filePath;
     constructor(filePath: string);

package/storage/FileFolderAPI.tsx

@@ -91,6 +91,18 @@ export function setFileAPIKey(key: string) {
     fileAPIKey = key;
 }
 
+// A directory handle to serve as the storage root instead of resolving one via
+// the picker / stored-pointer / remote flow. Set this in a context that can't run
+// the interactive resolution — most importantly a Web Worker, which has no DOM to
+// prompt with and no localStorage pointer. The owning window resolves the handle
+// (with its permission grant) and postMessages it in; the worker calls this before
+// touching any storage. When set, getDirectoryHandle returns it directly and skips
+// every DOM / localStorage branch below.
+let storageRootOverride: FileSystemDirectoryHandle | undefined;
+export function setStorageRootOverride(handle: FileSystemDirectoryHandle | undefined): void {
+    storageRootOverride = handle;
+}
+
 // ---- remote (server) storage config ----
 // Instead of a local folder, the user can point at a remoteFileServer.js instance (URL + password).
 // When configured, getFileStorageNested2 serves everything from that server. Persisted in localStorage.
@@ -442,6 +454,12 @@ export function pickPrivateFolder(name: string): void {
 // (we actually connect) before use; if it no longer works we re-prompt, just like a local folder whose
 // permission was lost. Blocks until ready (or the user dismisses, which rejects).
 export const getDirectoryHandle = lazy(async function getDirectoryHandle(): Promise<DirectoryWrapper> {
+    // An injected root (e.g. a Web Worker handed the handle by its owning window)
+    // short-circuits the whole interactive resolution — no picker, no DOM, no
+    // localStorage. Must come first so a worker never reaches the branches below.
+    if (storageRootOverride) {
+        return storageRootOverride as unknown as DirectoryWrapper;
+    }
     if (isNode()) {
         return new NodeJSDirectoryHandleWrapper(path.resolve("./data/"));
     }

package/storage/IArchives.d.ts

@@ -0,0 +1,37 @@
+/// <reference types="node" />
+/// <reference types="node" />
+export type ArchiveFileInfo = {
+    path: string;
+    createTime: number;
+    size: number;
+};
+export interface IArchives {
+    getDebugName(): string;
+    get(fileName: string, config?: {
+        range?: {
+            start: number;
+            end: number;
+        };
+    }): Promise<Buffer | undefined>;
+    set(fileName: string, data: Buffer): Promise<void>;
+    del(fileName: string): Promise<void>;
+    /** Streams a file too large to hold in memory. getNextData returns undefined when done. */
+    setLargeFile(config: {
+        path: string;
+        getNextData(): Promise<Buffer | undefined>;
+    }): Promise<void>;
+    getInfo(fileName: string): Promise<{
+        writeTime: number;
+        size: number;
+    } | undefined>;
+    find(prefix: string, config?: {
+        shallow?: boolean;
+        type: "files" | "folders";
+    }): Promise<string[]>;
+    findInfo(prefix: string, config?: {
+        shallow?: boolean;
+        type: "files" | "folders";
+    }): Promise<ArchiveFileInfo[]>;
+    /** Only works for public buckets (private buckets are API-access only). */
+    getURL(path: string): Promise<string>;
+}

package/storage/IArchives.ts

@@ -0,0 +1,20 @@
+module.allowclient = true;
+
+// The important operations of an archive bucket (extracted from ArchivesBackblaze), so other
+// backends (e.g. our own remote storage server) can be used interchangeably.
+
+export type ArchiveFileInfo = { path: string; createTime: number; size: number };
+
+export interface IArchives {
+    getDebugName(): string;
+    get(fileName: string, config?: { range?: { start: number; end: number } }): Promise<Buffer | undefined>;
+    set(fileName: string, data: Buffer): Promise<void>;
+    del(fileName: string): Promise<void>;
+    /** Streams a file too large to hold in memory. getNextData returns undefined when done. */
+    setLargeFile(config: { path: string; getNextData(): Promise<Buffer | undefined> }): Promise<void>;
+    getInfo(fileName: string): Promise<{ writeTime: number; size: number } | undefined>;
+    find(prefix: string, config?: { shallow?: boolean; type: "files" | "folders" }): Promise<string[]>;
+    findInfo(prefix: string, config?: { shallow?: boolean; type: "files" | "folders" }): Promise<ArchiveFileInfo[]>;
+    /** Only works for public buckets (private buckets are API-access only). */
+    getURL(path: string): Promise<string>;
+}

package/storage/TransactionStorage.d.ts

@@ -11,12 +11,13 @@ export declare class TransactionStorage implements IStorage<Buffer> {
     private rawStorage;
     private debugName;
     private writeDelay;
+    private resyncFromDisk;
     cache: Map<string, TransactionEntry>;
     private diskFiles;
     private currentChunk;
     private entryCount;
     private static allStorage;
-    constructor(rawStorage: IStorageRaw, debugName: string, writeDelay?: number);
+    constructor(rawStorage: IStorageRaw, debugName: string, writeDelay?: number, resyncFromDisk?: boolean);
     static compressAll(): Promise<void>;
     private resyncCallbacks;
     watchResync(callback: () => void): void;

package/storage/TransactionStorage.ts

@@ -92,7 +92,11 @@ export class TransactionStorage implements IStorage<Buffer> {
     constructor(
         private rawStorage: IStorageRaw,
         private debugName: string,
-        private writeDelay = WRITE_DELAY
+        private writeDelay = WRITE_DELAY,
+        // When set, we poll the underlying storage and reload if another process/tab writes new
+        // chunk files. Off by default, as it costs a periodic disk scan and most collections are
+        // only written by a single process.
+        private resyncFromDisk = false
     ) {
         TransactionStorage.allStorage.push(this);
         // VERY useful for debugging.
@@ -282,7 +286,7 @@ export class TransactionStorage implements IStorage<Buffer> {
     private async loadAllTransactions(initialLoad?: boolean): Promise<string[]> {
         if (isInBuild()) return [];
 
-        if (initialLoad) {
+        if (initialLoad && this.resyncFromDisk) {
             runInfinitePoll(DISK_CHECK_INTERVAL, () => this.checkDisk());
         }
 

package/storage/backblaze.d.ts

@@ -1,6 +1,7 @@
 /// <reference types="node" />
 /// <reference types="node" />
-export declare class ArchivesBackblaze {
+import { IArchives } from "./IArchives";
+export declare class ArchivesBackblaze implements IArchives {
     private config;
     constructor(config: {
         bucketName: string;

package/storage/backblaze.ts

@@ -9,6 +9,7 @@ import debugbreak from "debugbreak";
 import dns from "dns";
 import { getSecret } from "../misc/getSecret";
 import { httpsRequest } from "socket-function/src/https";
+import { IArchives } from "./IArchives";
 
 type BackblazeCreds = {
     applicationKeyId: string;
@@ -372,7 +373,7 @@ const getAPI = lazy(async () => {
 type B2Api = (typeof getAPI) extends () => Promise<infer T> ? T : never;
 
 
-export class ArchivesBackblaze {
+export class ArchivesBackblaze implements IArchives {
     public constructor(private config: {
         bucketName: string;
         public?: boolean;

package/storage/remoteStorage/ArchivesRemote.d.ts

@@ -0,0 +1,67 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { IArchives, ArchiveFileInfo } from "../IArchives";
+export type ArchivesRemoteConfig = {
+    address: string;
+    port: number;
+    account: string;
+    bucketName: string;
+    public?: boolean;
+    fast?: boolean;
+    writeDelay?: number;
+};
+export declare function buildPublicFileURL(config: {
+    address: string;
+    port: number;
+    account: string;
+    bucketName: string;
+    path: string;
+}): string;
+export declare function authenticateStorage(config: {
+    address: string;
+    port: number;
+    nodeId: string;
+}): Promise<{
+    machineId: string;
+    ip: string;
+}>;
+export declare class ArchivesRemote implements IArchives {
+    private config;
+    constructor(config: ArchivesRemoteConfig);
+    private nodeId;
+    private controller;
+    private setupDone;
+    private lastDeniedLog;
+    getDebugName(): string;
+    private authenticate;
+    private callAuthed;
+    waitingForAccess(): Promise<string | undefined>;
+    private onAccessDenied;
+    private ensureSetup;
+    private call;
+    get(fileName: string, config?: {
+        range?: {
+            start: number;
+            end: number;
+        };
+    }): Promise<Buffer | undefined>;
+    set(fileName: string, data: Buffer): Promise<void>;
+    del(fileName: string): Promise<void>;
+    getInfo(fileName: string): Promise<{
+        writeTime: number;
+        size: number;
+    } | undefined>;
+    findInfo(prefix: string, config?: {
+        shallow?: boolean;
+        type: "files" | "folders";
+    }): Promise<ArchiveFileInfo[]>;
+    find(prefix: string, config?: {
+        shallow?: boolean;
+        type: "files" | "folders";
+    }): Promise<string[]>;
+    setLargeFile(config: {
+        path: string;
+        getNextData(): Promise<Buffer | undefined>;
+    }): Promise<void>;
+    getURL(path: string): Promise<string>;
+}