@useupup/core 3.3.0

package/dist/core-bea2ceca.d.cts

@@ -0,0 +1,651 @@
+import { a as UploadFile, c as UploadStatus, F as FileSource, P as PipelineStep } from './contracts-pipeline-cf177270.cjs';
+import { h as UploadResult, M as MaxFileSizeObject, R as ResumableUploadOptions } from './contracts-strategies-378a16b7.cjs';
+import { L as LocaleBundle, a as UpupLocaleCode } from './ui-translations-c5d00392.cjs';
+
+type ImageEditorOptions = {
+    enabled?: boolean;
+    display?: 'inline' | 'modal';
+    autoOpen?: 'never' | 'single' | 'always';
+    output?: {
+        mimeType?: string;
+        quality?: number;
+        fileName?: (original: File) => string;
+    };
+    tabs?: ('Adjust' | 'Annotate' | 'Filters' | 'Finetune' | 'Resize' | 'Watermark')[];
+    tools?: ('Crop' | 'Rotate' | 'Flip' | 'Brightness' | 'Contrast' | 'HSV' | 'Blur' | 'Text' | 'Line' | 'Rect' | 'Ellipse' | 'Polygon' | 'Pen' | 'Arrow' | 'Image')[];
+    onOpen?: (file: UploadFile) => void;
+    onCancel?: (file: UploadFile) => void;
+    onSave?: (editedFile: UploadFile, originalFile: UploadFile) => void;
+};
+type ResolvedImageEditorOptions = Required<Pick<ImageEditorOptions, 'enabled' | 'autoOpen' | 'display'>> & Omit<ImageEditorOptions, 'enabled' | 'autoOpen' | 'display'>;
+type ImageCompressionOptions = {
+    quality?: number;
+    maxWidth?: number;
+    maxHeight?: number;
+    mimeType?: string;
+    convertSize?: number;
+};
+type ThumbnailGeneratorOptions = {
+    thumbnailWidth?: number;
+    thumbnailHeight?: number;
+    thumbnailType?: string;
+    waitForThumbnailsBeforeUpload?: boolean;
+};
+
+interface CoreEvents {
+    'state-change': {
+        status?: UploadStatus;
+        error?: Error;
+        files?: Map<string, UploadFile>;
+        progress?: {
+            totalFiles: number;
+            completedFiles: number;
+            percentage: number;
+        };
+    };
+    'upload-start': {
+        retry?: boolean;
+        fileId?: string;
+    };
+    'file-upload-start': {
+        file: UploadFile;
+    };
+    'upload-progress': {
+        fileId: string;
+        loaded: number;
+        total: number;
+    };
+    'upload-success': {
+        file: UploadFile;
+        result: UploadResult;
+    };
+    'upload-error': {
+        error: Error;
+        file?: UploadFile;
+    };
+    'upload-all-complete': UploadFile[];
+    'upload-pause': Record<string, never>;
+    'upload-resume': Record<string, never>;
+    'upload-cancel': Record<string, never>;
+    'files-added': UploadFile[];
+    'file-removed': UploadFile;
+    'file-rejected': {
+        count: number;
+    };
+    'file-replaced': {
+        file: UploadFile;
+    };
+    'files-cleared': Record<string, never>;
+    'files-set': {
+        count: number;
+    };
+    'files-reordered': {
+        fileIds: string[];
+    };
+    'restriction-failed': {
+        error: unknown;
+    };
+    'plugin-registered': {
+        name: string;
+    };
+    'options-updated': {
+        partial: Partial<CoreOptions>;
+    };
+    retry: {
+        fileId?: string | undefined;
+    };
+    'snapshot-restored': {
+        count: number;
+        status: UploadStatus;
+    };
+    'crash-recovery-restored': Record<string, never>;
+    destroyed: Record<string, never>;
+    done: Record<string, never>;
+    'state-reset': Record<string, never>;
+    'auto-upload': {
+        count: number;
+    };
+    'connection-online': Record<string, never>;
+    'connection-offline': Record<string, never>;
+    'image-editor-open': {
+        file: UploadFile;
+    };
+    'image-editor-cancel': {
+        file: UploadFile;
+    };
+    'image-editor-save': {
+        file: UploadFile;
+        original: UploadFile;
+    };
+    'drag-over': Record<string, never>;
+    'drag-leave': Record<string, never>;
+    drop: {
+        files: File[];
+    };
+    'folder-drop-blocked': {
+        acceptedFiles: number;
+    };
+    paste: {
+        files: File[];
+    };
+    'pipeline-start': {
+        fileId: string;
+        steps: string[];
+    };
+    'pipeline-step': {
+        fileId: string;
+        step: string;
+    };
+    'pipeline-complete': {
+        fileId: string;
+    };
+    'pipeline-error': {
+        scope: string;
+        name: string;
+        message: string;
+    };
+    'source-click': {
+        sourceId: FileSource;
+    };
+    'source-view-cancel': {
+        sourceId: FileSource | undefined;
+    };
+    'browse-files': Record<string, never>;
+    'folder-select': {
+        count: number;
+    };
+    'url-submit': {
+        url: string;
+    };
+    'url-fetch': {
+        file: File;
+    };
+    'url-fetch-cancel': {
+        url: string;
+    };
+    'camera-capture': {
+        dataUrl: string;
+    };
+    'camera-confirm': {
+        file: File;
+    };
+    'file-preview-open': {
+        fileId: string;
+        fileName: string;
+    };
+    'file-preview-close': {
+        fileId: string;
+        fileName: string;
+    };
+}
+
+type EventHandler<T = unknown> = (payload: T) => void;
+declare class EventEmitter<TEvents extends object = Record<string, unknown>> {
+    private handlers;
+    on<K extends string & keyof TEvents>(event: K, handler: EventHandler<TEvents[K]>): () => void;
+    on(event: string, handler: EventHandler): () => void;
+    off(event: string, handler: EventHandler): void;
+    emit<K extends string & keyof TEvents>(event: K, payload: TEvents[K]): void;
+    emit(event: string, payload?: unknown): void;
+    removeAllListeners(event?: string): void;
+}
+
+interface UpupPlugin {
+    /** Unique name — used for deduplication and debugging */
+    name: string;
+    /**
+     * Called once when the plugin is registered, with core's event bus. The one
+     * plugin lifecycle hook (F-607) — a plugin subscribes to core events and
+     * emits its own through this emitter. Optional: a plugin that only needs
+     * registration (dedup + storage) may omit it.
+     */
+    init?(emitter: EventEmitter): void;
+}
+type ExtensionMethods = Record<string, (...args: unknown[]) => unknown>;
+declare class PluginManager {
+    private plugins;
+    private extensions;
+    register(plugin: UpupPlugin): void;
+    registerExtension(name: string, methods: ExtensionMethods): void;
+    getPlugin(name: string): UpupPlugin | undefined;
+    getExtension(name: string): ExtensionMethods | undefined;
+    getExtensions(): Record<string, ExtensionMethods>;
+    destroy(): void;
+}
+
+/**
+ * @param bytes assign keyword depend on size
+ */
+declare const bytesToSize: (bytes: number) => string;
+/**
+ * @param size
+ * @param unit
+ */
+declare const sizeToBytes: (size: number, unit?: "B" | "KB" | "MB" | "GB" | "TB" | "PB" | "EB" | "ZB" | "YB") => number;
+/**
+ * @param file
+ * @param sizeLimit
+ * @param mode
+ */
+declare function checkFileSize(file: File, sizeLimit: MaxFileSizeObject | undefined, mode?: 'max' | 'min'): boolean;
+/**
+ * Maximum file size (in bytes) for which text-based preview is allowed.
+ * Files exceeding this threshold will show a static icon instead of rendering content,
+ * preventing the browser from freezing on large text files (e.g. 3MB+ JSON).
+ */
+declare const PREVIEW_MAX_TEXT_SIZE: number;
+/**
+ * Maximum number of characters to render in the preview portal for text files.
+ * Content beyond this limit is truncated with an indicator.
+ */
+declare const PREVIEW_TEXT_TRUNCATE_LENGTH = 100000;
+/**
+ * Determines whether a file is a text-based file that could be previewed as text.
+ */
+declare function fileGetIsText(fileType: string | undefined, fileName?: string): boolean;
+/**
+ * Returns true if a text file is small enough to safely preview inline.
+ */
+declare function fileCanPreviewText(fileType: string | undefined, fileName: string | undefined, fileSize: number | undefined): boolean;
+declare function fileGetIsImage(fileType?: string): boolean;
+declare function fileGetIsPdf(fileType: string | undefined, fileName?: string): boolean;
+declare function fileGetExtension(fileType: string | undefined, fileName?: string): string;
+declare function fileIs3D(ext: string): boolean;
+type FileProgress = {
+    id: string;
+    loaded: number;
+    total: number;
+};
+type FilesProgressMap = Record<string, FileProgress>;
+declare function searchDriveFiles<T extends {
+    name: string;
+}>(files: T[], searchTerm: string, options?: {
+    caseSensitive?: boolean;
+    exactMatch?: boolean;
+    maxResults?: number;
+}): T[];
+
+interface GoogleDriveConfig {
+    clientId: string;
+    apiKey: string;
+    appId: string;
+}
+interface OneDriveConfig {
+    clientId: string;
+    redirectUri?: string;
+}
+interface DropboxConfig {
+    clientId: string;
+    redirectUri?: string;
+}
+interface BoxConfig {
+    clientId: string;
+    redirectUri?: string;
+}
+/** Public cloud-drive configuration — identical shape from framework props down to plugins. */
+interface CloudDrivesConfig {
+    googleDrive?: GoogleDriveConfig;
+    oneDrive?: OneDriveConfig;
+    dropbox?: DropboxConfig;
+    box?: BoxConfig;
+}
+
+interface FileManagerOptions {
+    allowedFileTypes?: string | undefined;
+    limit?: number | undefined;
+    maxFileSize?: MaxFileSizeObject | undefined;
+    minFileSize?: MaxFileSizeObject | undefined;
+    maxTotalFileSize?: MaxFileSizeObject | undefined;
+    contentDeduplication?: boolean | undefined;
+    onBeforeFileAdded?: ((file: File) => boolean | File | undefined | Promise<boolean | File | undefined>) | undefined;
+}
+declare class FileManager {
+    private files;
+    private options;
+    constructor(options: FileManagerOptions);
+    updateOptions(options: Partial<FileManagerOptions>): void;
+    getFiles(): ReadonlyMap<string, UploadFile>;
+    /**
+     * Immutable file-status transition: produce a NEW UploadFile carrying the patch,
+     * store and return it. FileManager is the sole writer of a file's status/key/metadata
+     * (F-144), and the new reference lets the orchestrator's ref-diff projection track the
+     * transition (F-145).
+     *
+     * Constraint: object-spread (`{ ...prev }`) would strip File's blob data and methods —
+     * they live in internal slots / on the prototype, not as own-enumerable props — leaving
+     * a plain object that breaks `xhr.send(file)` in the direct-upload strategy. So we
+     * re-wrap the same backing bytes into a fresh File (a view, not a copy) and copy the
+     * UploadFile fields onto it — mirroring `cloneUploadFile` (steps/image-utils.ts). Do
+     * NOT "simplify" this back to a spread.
+     */
+    updateFile(id: string, patch: Partial<UploadFile>): UploadFile | undefined;
+    private validateFile;
+    private collectAcceptedFiles;
+    private deduplicateByContent;
+    private assertBatchFits;
+    addFiles(nativeFiles: File[]): Promise<UploadFile[]>;
+    removeFile(id: string): UploadFile | undefined;
+    replaceFile(id: string, file: File | UploadFile): UploadFile;
+    removeAll(): void;
+    /** Bulk-apply pipeline-produced files (already UploadFile with status/key set). */
+    applyProcessed(files: UploadFile[]): void;
+    /** Re-instate a prior snapshot: clear and repopulate from entries. */
+    restore(entries: [string, UploadFile][]): void;
+    setFiles(nativeFiles: File[]): Promise<UploadFile[]>;
+    reorderFiles(fileIds: string[]): void;
+}
+
+interface PersistentStorage {
+    get(key: string): Promise<unknown>;
+    set(key: string, value: unknown): Promise<void>;
+    delete(key: string): Promise<void>;
+}
+declare class CrashRecoveryManager {
+    private storage;
+    constructor(storage: PersistentStorage);
+    save(snapshot: unknown): Promise<void>;
+    restore(): Promise<unknown>;
+    clear(): Promise<void>;
+}
+/**
+ * IndexedDB-based storage for browser environments.
+ * Falls back gracefully when IndexedDB is unavailable (SSR, privacy mode).
+ */
+declare class IndexedDBStorage implements PersistentStorage {
+    private dbName;
+    private storeName;
+    /** ONE cached connection for the storage's lifetime — never closed after
+     *  an operation. Firefox ties Blob/File handles read from IndexedDB to
+     *  the connection they were read over: with the old open-per-operation /
+     *  close-on-complete lifecycle, the File revived by the crash-recovery
+     *  restore lost its backing store shortly after the restore's transaction
+     *  closed, and mid-resume slice reads rejected with AbortError ("The
+     *  operation was aborted") — a Firefox-only reload-resume stall reproduced
+     *  against both MinIO and Backblaze B2 (Chromium materializes IndexedDB
+     *  blobs independently of the connection and never failed). The cache
+     *  still yields: `versionchange` (a deleteDatabase/upgrade elsewhere)
+     *  closes and drops it so the other context is never blocked, and a
+     *  browser-initiated `close` drops it so the next operation reopens. */
+    private dbPromise;
+    constructor(dbName?: string);
+    private getDB;
+    /** Close and release the cached connection. Safe at any time — the next
+     *  operation reopens. `UpupCore.destroy()` calls this so an unmounted
+     *  uploader doesn't keep the database held open (pending transactions
+     *  still drain first per the IndexedDB spec, so a queued snapshot write
+     *  is never cut off mid-transaction). */
+    close(): void;
+    get(key: string): Promise<unknown>;
+    set(key: string, value: unknown): Promise<void>;
+    delete(key: string): Promise<void>;
+}
+
+interface UpupCorsConfig {
+    dangerouslyAutoConfigure?: boolean;
+    allowedOrigins: string[];
+    allowedMethods?: string[];
+    allowedHeaders?: string[];
+    maxAgeSeconds?: number;
+}
+interface CrashRecoveryOptions {
+    storage?: PersistentStorage;
+}
+interface CoreOptions extends FileManagerOptions {
+    uploadEndpoint?: string | undefined;
+    serverUrl?: string | undefined;
+    provider?: string | undefined;
+    mode?: 'client' | 'server' | undefined;
+    plugins?: UpupPlugin[] | undefined;
+    pipeline?: PipelineStep[] | undefined;
+    resumable?: ResumableUploadOptions | undefined;
+    heicConversion?: boolean | undefined;
+    stripExifData?: boolean | undefined;
+    imageCompression?: boolean | object | undefined;
+    thumbnailGenerator?: boolean | object | undefined;
+    checksumVerification?: boolean | undefined;
+    /**
+     * Web Worker offload for the file pipeline (hash/heic/exif/thumbnail/compress).
+     * Unset/`true` = auto (workers used when supported, transparent main-thread
+     * fallback otherwise). `false` = force the main thread.
+     */
+    webWorker?: boolean | undefined;
+    /**
+     * Web-worker task timeout in ms. Default 30000. On timeout the task falls
+     * back to main-thread processing (it never fails the file).
+     */
+    workerTimeoutMs?: number | undefined;
+    maxRetries?: number | undefined;
+    maxConcurrentUploads?: number | undefined;
+    autoUpload?: boolean | undefined;
+    /**
+     * React to browser connectivity: going offline mid-upload pauses the run
+     * (so multipart sessions persist instead of burning retries against a dead
+     * network), and coming back online resumes it — only when the pause was
+     * offline-initiated, never overriding a pause the user chose. Default on;
+     * `false` restores the fail-and-retry behavior. No-op outside a browser.
+     */
+    networkAware?: boolean | undefined;
+    fastAbortThreshold?: number | undefined;
+    isSuccessfulCall?: ((response: {
+        status: number;
+        headers: Record<string, string>;
+        body: unknown;
+    }) => boolean | Promise<boolean>) | undefined;
+    crashRecovery?: boolean | CrashRecoveryOptions | undefined;
+    onError?: ((error: string | Error) => void) | undefined;
+    metadata?: Record<string, unknown> | undefined;
+    cors?: UpupCorsConfig | undefined;
+    /**
+     * i18n configuration. Accepts either:
+     * - a full LocaleBundle (`import { enUS } from './contracts'`) — also
+     *   drives the file-pipeline translator (`context.t` inside pipeline
+     *   steps), not just the UI translator.
+     * - a BCP 47 locale code string (e.g. `'fr-FR'`) — resolves to lang/dir
+     *   only until a locale registry exists; consumers are responsible for
+     *   resolving codes to bundles via `i18n.loadLocale`.
+     */
+    locale?: LocaleBundle | UpupLocaleCode | undefined;
+    cloudDrives?: CloudDrivesConfig | undefined;
+}
+type ValidationResult = {
+    file: File;
+    valid: boolean;
+    errors: Array<{
+        code: string;
+        message: string;
+    }>;
+};
+type UploadOptions = {
+    checksumVerification?: boolean;
+    imageCompression?: boolean | object;
+    heicConversion?: boolean;
+    stripExifData?: boolean;
+    maxRetries?: number;
+    metadata?: Record<string, string>;
+};
+
+declare class UpupCore {
+    private emitter;
+    private pluginManager;
+    private fileManager;
+    private pipelineEngine;
+    private uploadManager;
+    private _status;
+    private _error;
+    private crashRecovery;
+    private crashRecoveryStorage;
+    private crashRecoveryUnsubscribe;
+    /** Every crash-recovery storage write flows through this one promise chain.
+     *  Blob snapshots of large files make IndexedDB puts slow; fire-and-forget
+     *  save/clear calls complete out of order, so a save started before
+     *  completion can land after the completion clear and resurrect a finished
+     *  upload as a resumable one. FIFO ordering makes the last requested op the
+     *  last applied op. */
+    private crashRecoveryChain;
+    /** True while a snapshot sync is queued but not yet run. Progress ticks
+     *  arrive far faster than a large snapshot writes; coalescing them into the
+     *  one queued sync (which reads state at write time) keeps it to at most
+     *  one write in flight plus one pending, instead of N stacked blob puts. */
+    private crashRecoverySyncQueued;
+    private fileOverrides;
+    private pauseRequested;
+    private cancelRequested;
+    private destroyed;
+    /** True only while the CURRENT pause was made by the offline handler —
+     *  the one case `online` may resume. A pause the user chose stays theirs. */
+    private offlinePausedRun;
+    private detachNetworkListeners;
+    private activeRun;
+    private workerProvider;
+    options: CoreOptions;
+    constructor(options: CoreOptions);
+    /** Connectivity reactions (`networkAware`, default on): `offline` pauses
+     *  an active run — with `persist` on, that keeps the multipart session
+     *  alive instead of burning whole-run retries against a dead network —
+     *  and `online` resumes it, but ONLY when this handler made the pause.
+     *  SSR/node-safe: without a window this installs nothing. */
+    private installNetworkAwareness;
+    /** The one projection of CoreOptions the FileManager consumes — construction
+     *  and updateOptions() must stay in lockstep, so both call this. */
+    private fileManagerOptions;
+    get files(): ReadonlyMap<string, UploadFile>;
+    get status(): UploadStatus;
+    get error(): Error | null;
+    get progress(): {
+        totalFiles: number;
+        completedFiles: number;
+        percentage: number;
+    };
+    /**
+     * Crash-recovery persistence is best-effort by design — a failed save/clear
+     * must never break an upload. But full silence hides a dead durability
+     * opt-in (F-734): surface failures dev-only, matching the worker-fallback
+     * convention in maybeCreateWorkerProvider().
+     */
+    private warnCrashRecoveryFailure;
+    private configureCrashRecovery;
+    /** Queue a snapshot write that reads files/status at WRITE time, not at
+     *  event time — so the write that runs last always reflects the state that
+     *  came last, and a completion observed while a save is queued turns that
+     *  queued write into the clear instead of racing it. */
+    private queueCrashRecoverySync;
+    /** Queue an unconditional clear behind any in-flight snapshot write. The
+     *  default manager is captured at call time so a clear requested before
+     *  disable/destroy still applies after the field is nulled. */
+    private queueCrashRecoveryClear;
+    private enqueueCrashRecoveryOp;
+    private disableCrashRecovery;
+    use(plugin: UpupPlugin): this;
+    registerExtension(name: string, methods: ExtensionMethods): void;
+    getPlugin(name: string): UpupPlugin | undefined;
+    getExtension(name: string): ExtensionMethods | undefined;
+    get ext(): Record<string, ExtensionMethods>;
+    addFiles(files: File[], overrides?: Partial<UploadOptions>): Promise<void>;
+    /**
+     * Discard the persisted multipart sessions of files the user just threw
+     * away (cancel / removeFile / removeAll), aborting them server-side on the
+     * way out. With `resumable.persist` on, a failed or cancelled upload
+     * deliberately keeps its server-side parts alive for a later resume — so
+     * an explicit discard is the ONE place that has to say "no, really, drop
+     * it", or the user pays storage for parts nothing will ever finish.
+     *
+     * Fire-and-forget and fully swallowed: cancelling must never throw or wait.
+     */
+    private discardPersistedMultipartSessions;
+    removeFile(id: string): void;
+    removeAll(): void;
+    setFiles(files: File[]): Promise<void>;
+    /** Update options after construction (e.g. when React props change). */
+    updateOptions(partial: Partial<CoreOptions>): void;
+    reorderFiles(fileIds: string[]): void;
+    private maybeCreateWorkerProvider;
+    private hasUploadTarget;
+    private createUploadManager;
+    private markFilesReady;
+    private updatePendingFileStatuses;
+    private markUnsuccessfulFilesFailed;
+    private uploadFiles;
+    validateFiles(files: File[]): Promise<ValidationResult[]>;
+    upload(): Promise<UploadFile[]>;
+    private resetRunFlags;
+    private runUpload;
+    /**
+     * The single terminal-failure path shared by all three run flavors
+     * (runUpload / runRetry / resume). They previously diverged (F-729): only
+     * runUpload marked leftover files FAILED, and resume never invoked
+     * options.onError — a retry/resume failure looked different to consumers
+     * than the identical first-run failure for no reason.
+     */
+    private terminalRunFailure;
+    replaceFile(id: string, file: File | UploadFile): void;
+    /**
+     * Pause in-flight uploads by aborting the current abort controller.
+     * Note: This cancels active HTTP requests. Resume will re-upload
+     * files that were in progress — true pause/resume of partial uploads
+     * requires multipart upload support.
+     */
+    pause(): void;
+    /**
+     * Resume uploads after a pause. Re-uploads files that did not
+     * complete successfully (those without a `key` set).
+     */
+    resume(): void;
+    cancel(): void;
+    retry(fileId?: string): Promise<UploadFile[]>;
+    private runRetry;
+    /**
+     * Bare event names are the typed CoreEvents catalog and nothing else —
+     * the untyped string overload is gone (F-723), so an unknown bare event is
+     * now a compile error at the emit/subscribe site. Namespaced drive-plugin
+     * events ('<provider>:<event>', e.g. 'google-drive:files-loaded') are
+     * dynamic by design — plugins emit them through core's bus (see use()) —
+     * and keep a template-literal passthrough.
+     */
+    on<K extends keyof CoreEvents>(event: K, handler: (payload: CoreEvents[K]) => void): () => void;
+    on(event: `${string}:${string}`, handler: (payload: unknown) => void): () => void;
+    off<K extends keyof CoreEvents>(event: K, handler: (payload: CoreEvents[K]) => void): void;
+    off(event: `${string}:${string}`, handler: (payload: unknown) => void): void;
+    emit<K extends keyof CoreEvents>(event: K, payload: CoreEvents[K]): void;
+    emit(event: `${string}:${string}`, data?: unknown): void;
+    getSnapshot(): {
+        files: [string, UploadFile][];
+        status: UploadStatus;
+    };
+    restore(snapshot: {
+        files: [string, UploadFile][];
+        status: UploadStatus;
+    }): void;
+    restoreFromCrashRecovery(): Promise<boolean>;
+    /** `resumable.autoResume` continues a crash-restored upload without the
+     *  explicit Resume click. Off by default on purpose: closing a tab is an
+     *  ambiguous signal — as often "cancel" as "oops" — so silently resuming
+     *  a transfer the user may have meant to kill is an integrator's call,
+     *  never the library's. Deferred a tick so the host finishes mounting
+     *  (the same guard autoUpload's timer carries, F-148), and re-checked at
+     *  fire time: the user may have discarded the restore in between. */
+    private maybeScheduleAutoResume;
+    /** A restored PAUSED file rendered "0 B of N" even when most of it was
+     *  already in storage — the persisted multipart session knows the real
+     *  offset, but nothing replayed it into the progress pipeline until the
+     *  user actually hit resume. Emit it here so the restored UI opens at the
+     *  byte count the resume will continue from. Same session gates as
+     *  tryResume (scope), minus the server round-trip: this is display-only
+     *  and must not spend a request; the authoritative recheck still happens
+     *  on resume. */
+    /** A finished multipart upload can die in the window between its
+     *  synchronous session removal and the asynchronous IndexedDB snapshot
+     *  clear — the next visit then restores a file the server already
+     *  assembled, offering a Resume that would re-upload all of it. The
+     *  session store is the tiebreaker: init writes the session synchronously
+     *  before the first byte moves and completion removes it synchronously,
+     *  so an UPLOADING-status file of multipart size with no session is a
+     *  stale snapshot, not a crashed upload. PROCESSING files never had a
+     *  session and stay restorable; so does everything below the multipart
+     *  threshold or outside persist mode. */
+    private isStaleMultipartRestore;
+    private seedRestoredProgress;
+    clearCrashRecovery(): Promise<void>;
+    destroy(): void;
+}
+
+export { type BoxConfig as B, type CoreEvents as C, type DropboxConfig as D, EventEmitter as E, type FilesProgressMap as F, type GoogleDriveConfig as G, type ImageEditorOptions as I, type OneDriveConfig as O, PluginManager as P, type ResolvedImageEditorOptions as R, type ThumbnailGeneratorOptions as T, UpupCore as U, type ValidationResult as V, type ImageCompressionOptions as a, type CloudDrivesConfig as b, type UpupPlugin as c, type CoreOptions as d, type UploadOptions as e, type UpupCorsConfig as f, type ExtensionMethods as g, type FileProgress as h, FileManager as i, CrashRecoveryManager as j, IndexedDBStorage as k, type PersistentStorage as l, bytesToSize as m, checkFileSize as n, PREVIEW_MAX_TEXT_SIZE as o, PREVIEW_TEXT_TRUNCATE_LENGTH as p, fileGetIsImage as q, fileGetIsPdf as r, sizeToBytes as s, fileGetIsText as t, fileCanPreviewText as u, fileGetExtension as v, fileIs3D as w, searchDriveFiles as x };