@useupup/core 3.3.0

package/dist/chunk-PMBR3OUW.js

@@ -0,0 +1,2359 @@
+import { UpupConfigError, UpupValidationError, UpupError, UpupNetworkError, UpupAuthError } from './chunk-GE4LIVXP.js';
+
+// src/events.ts
+var EventEmitter = class {
+  constructor() {
+    this.handlers = /* @__PURE__ */ new Map();
+  }
+  on(event, handler) {
+    let handlers = this.handlers.get(event);
+    if (!handlers) {
+      handlers = /* @__PURE__ */ new Set();
+      this.handlers.set(event, handlers);
+    }
+    handlers.add(handler);
+    return () => {
+      this.off(event, handler);
+    };
+  }
+  off(event, handler) {
+    this.handlers.get(event)?.delete(handler);
+  }
+  emit(event, payload) {
+    const handlers = this.handlers.get(event);
+    if (handlers) {
+      for (const handler of handlers) {
+        try {
+          handler(payload);
+        } catch (err) {
+          if (typeof process !== "undefined" && process.env.NODE_ENV !== "production") {
+            console.error(
+              `[upup] listener for "${event}" threw:`,
+              err
+            );
+          }
+        }
+      }
+    }
+  }
+  removeAllListeners(event) {
+    if (event) {
+      this.handlers.delete(event);
+    } else {
+      this.handlers.clear();
+    }
+  }
+};
+
+// src/plugin.ts
+var PluginManager = class {
+  constructor() {
+    this.plugins = /* @__PURE__ */ new Map();
+    this.extensions = /* @__PURE__ */ new Map();
+  }
+  register(plugin) {
+    if (this.plugins.has(plugin.name)) {
+      throw new UpupConfigError(
+        `Plugin "${plugin.name}" is already registered`,
+        "PLUGIN_ALREADY_REGISTERED"
+      );
+    }
+    this.plugins.set(plugin.name, plugin);
+  }
+  registerExtension(name, methods) {
+    if (this.extensions.has(name)) {
+      throw new UpupConfigError(
+        `Extension "${name}" is already registered`,
+        "EXTENSION_ALREADY_REGISTERED"
+      );
+    }
+    this.extensions.set(name, methods);
+  }
+  getPlugin(name) {
+    return this.plugins.get(name);
+  }
+  getExtension(name) {
+    return this.extensions.get(name);
+  }
+  getExtensions() {
+    return Object.fromEntries(this.extensions);
+  }
+  destroy() {
+    this.plugins.clear();
+    this.extensions.clear();
+  }
+};
+
+// src/validate-file-restrictions.ts
+function fileSizeInBytes(size) {
+  const units = {
+    B: 1,
+    KB: 1024,
+    MB: 1024 ** 2,
+    GB: 1024 ** 3
+  };
+  return size.size * (units[size.unit] ?? 1);
+}
+function matchesAccept(file, accept) {
+  const types = accept.split(",").map((t) => t.trim()).filter(Boolean);
+  if (types.length === 0 || types.some((type) => type === "*" || type === "*/*")) {
+    return true;
+  }
+  return types.some((type) => {
+    if (type.endsWith("/*")) {
+      return file.type.startsWith(type.replace("/*", "/"));
+    }
+    if (type.startsWith(".")) {
+      return file.name.toLowerCase().endsWith(type.toLowerCase());
+    }
+    return file.type === type;
+  });
+}
+function validateFileRestrictions(file, options) {
+  const errors = [];
+  if (options.allowedFileTypes && !matchesAccept(file, options.allowedFileTypes)) {
+    errors.push({
+      code: "TYPE_MISMATCH" /* TYPE_MISMATCH */,
+      message: `File type "${file.type}" is not accepted`
+    });
+  }
+  if (options.maxFileSize) {
+    const maxBytes = fileSizeInBytes(options.maxFileSize);
+    if (file.size > maxBytes) {
+      errors.push({
+        code: "FILE_TOO_LARGE" /* FILE_TOO_LARGE */,
+        message: `File "${file.name}" exceeds maximum size`
+      });
+    }
+  }
+  if (options.minFileSize) {
+    const minBytes = fileSizeInBytes(options.minFileSize);
+    if (file.size < minBytes) {
+      errors.push({
+        code: "FILE_TOO_SMALL" /* FILE_TOO_SMALL */,
+        message: `File "${file.name}" is below minimum size`
+      });
+    }
+  }
+  return errors;
+}
+
+// src/file-manager.ts
+var fileIdCounter = 0;
+function generateFileId() {
+  return `upup-${Date.now()}-${++fileIdCounter}`;
+}
+async function computeContentHash(file) {
+  const buffer = await file.arrayBuffer();
+  const bytes = new Uint8Array(buffer);
+  const subtleCrypto = typeof crypto !== "undefined" ? crypto.subtle : void 0;
+  if (subtleCrypto) {
+    const hashBuffer = await subtleCrypto.digest("SHA-256", buffer);
+    return Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  let hash = 2166136261;
+  for (const byte of bytes) {
+    hash ^= byte;
+    hash = Math.imul(hash, 16777619);
+  }
+  return `fnv1a-${(hash >>> 0).toString(16).padStart(8, "0")}`;
+}
+function storedContentHash(file) {
+  const metadata = file.metadata;
+  return (typeof metadata?.originalContentHash === "string" ? metadata.originalContentHash : void 0) ?? (typeof metadata?.checksum === "string" ? metadata.checksum : void 0) ?? // eslint-disable-next-line @typescript-eslint/no-deprecated -- v3 removal tracked
+  file.checksumSHA256 ?? // eslint-disable-next-line @typescript-eslint/no-deprecated -- v3 removal tracked
+  file.fileHash;
+}
+function applyContentHash(file, hash) {
+  const fileRecord = file;
+  fileRecord.fileHash = hash;
+  file.metadata = {
+    ...file.metadata,
+    originalContentHash: hash
+  };
+  return file;
+}
+function contentHashPatch(file, hash) {
+  const patch = {
+    fileHash: hash,
+    metadata: { ...file.metadata, originalContentHash: hash }
+  };
+  return patch;
+}
+function nativeToUploadFile(file, source = "local" /* LOCAL */) {
+  const url = typeof URL !== "undefined" && typeof URL.createObjectURL === "function" ? URL.createObjectURL(file) : void 0;
+  const extendedFile = file;
+  const relativePath = typeof extendedFile.relativePath === "string" && extendedFile.relativePath.trim() !== "" ? extendedFile.relativePath : typeof extendedFile.webkitRelativePath === "string" && extendedFile.webkitRelativePath.trim() !== "" ? extendedFile.webkitRelativePath : void 0;
+  const existingMetadata = extendedFile.metadata && typeof extendedFile.metadata === "object" && !Array.isArray(extendedFile.metadata) ? extendedFile.metadata : {};
+  const uploadFile = Object.assign(file, {
+    id: generateFileId(),
+    source,
+    status: "IDLE" /* IDLE */,
+    metadata: {
+      ...existingMetadata,
+      ...relativePath ? { relativePath } : {}
+    },
+    ...url !== void 0 ? { url } : {}
+  });
+  if (relativePath) {
+    try {
+      Object.defineProperty(uploadFile, "relativePath", {
+        value: relativePath,
+        configurable: true,
+        enumerable: false,
+        writable: true
+      });
+    } catch {
+      try {
+        uploadFile.relativePath = relativePath;
+      } catch {
+      }
+    }
+  }
+  return uploadFile;
+}
+function revokeObjectUrl(file) {
+  if (file?.url && file.url.startsWith("blob:") && typeof URL !== "undefined" && typeof URL.revokeObjectURL === "function") {
+    URL.revokeObjectURL(file.url);
+  }
+}
+var FileManager = class {
+  constructor(options) {
+    this.files = /* @__PURE__ */ new Map();
+    this.options = options;
+  }
+  updateOptions(options) {
+    this.options = {
+      ...this.options,
+      ...options
+    };
+  }
+  getFiles() {
+    return new Map(this.files);
+  }
+  /**
+   * 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, patch) {
+    const prev = this.files.get(id);
+    if (!prev) return void 0;
+    const next = new File([prev], prev.name, {
+      type: prev.type,
+      lastModified: prev.lastModified
+    });
+    Object.assign(next, prev, { relativePath: prev.relativePath }, patch);
+    const updated = next;
+    this.files.set(id, updated);
+    return updated;
+  }
+  validateFile(file) {
+    const [violation] = validateFileRestrictions(file, this.options);
+    if (violation) {
+      throw new UpupValidationError(
+        violation.message,
+        violation.code,
+        file
+      );
+    }
+  }
+  async collectAcceptedFiles(nativeFiles) {
+    const accepted = [];
+    for (const nativeFile of nativeFiles) {
+      let candidate = nativeFile;
+      if (this.options.onBeforeFileAdded) {
+        const result = await this.options.onBeforeFileAdded(nativeFile);
+        if (result === false) continue;
+        if (result instanceof File) {
+          candidate = result;
+        }
+      }
+      this.validateFile(candidate);
+      accepted.push(candidate);
+    }
+    return accepted;
+  }
+  async deduplicateByContent(nativeFiles, existingFiles) {
+    if (!this.options.contentDeduplication) {
+      return nativeFiles.map((file) => ({ file }));
+    }
+    const seen = /* @__PURE__ */ new Set();
+    for (const existing of existingFiles) {
+      const nativeExisting = existing;
+      const hash = storedContentHash(existing) ?? (typeof nativeExisting.arrayBuffer === "function" ? await computeContentHash(nativeExisting) : void 0);
+      if (hash) {
+        if (storedContentHash(existing) !== hash) {
+          this.updateFile(
+            existing.id,
+            contentHashPatch(existing, hash)
+          );
+        }
+        seen.add(hash);
+      }
+    }
+    const accepted = [];
+    for (const file of nativeFiles) {
+      const hash = await computeContentHash(file);
+      if (seen.has(hash)) continue;
+      seen.add(hash);
+      accepted.push({ file, hash });
+    }
+    return accepted;
+  }
+  assertBatchFits(files, existingFiles, fallbackFile) {
+    if (files.length === 0) return;
+    const violatingFile = files[0] ?? fallbackFile;
+    if (!violatingFile) {
+      throw new UpupError(
+        "assertBatchFits: no file available to attach to the violation error",
+        "BAD_REQUEST" /* BAD_REQUEST */
+      );
+    }
+    const existing = [...existingFiles];
+    if (this.options.limit) {
+      const remainingSlots = this.options.limit - existing.length;
+      if (remainingSlots <= 0 || files.length > remainingSlots) {
+        throw new UpupValidationError(
+          `Adding ${files.length} files would exceed the limit of ${this.options.limit}`,
+          "LIMIT_EXCEEDED" /* LIMIT_EXCEEDED */,
+          violatingFile
+        );
+      }
+    }
+    if (this.options.maxTotalFileSize) {
+      const maxTotal = fileSizeInBytes(this.options.maxTotalFileSize);
+      const currentTotal = existing.reduce((sum, f) => sum + f.size, 0);
+      const newTotal = files.reduce((sum, f) => sum + f.size, 0);
+      if (currentTotal + newTotal > maxTotal) {
+        throw new UpupValidationError(
+          "Total file size exceeds maximum",
+          "TOTAL_SIZE_EXCEEDED" /* TOTAL_SIZE_EXCEEDED */,
+          violatingFile
+        );
+      }
+    }
+  }
+  async addFiles(nativeFiles) {
+    const acceptedNativeFiles = await this.collectAcceptedFiles(nativeFiles);
+    const dedupedFiles = await this.deduplicateByContent(
+      acceptedNativeFiles,
+      this.files.values()
+    );
+    this.assertBatchFits(
+      dedupedFiles.map((item) => item.file),
+      this.files.values(),
+      nativeFiles[0]
+    );
+    const accepted = dedupedFiles.map(({ file, hash }) => {
+      const uploadFile = nativeToUploadFile(file);
+      return hash ? applyContentHash(uploadFile, hash) : uploadFile;
+    });
+    for (const file of accepted) {
+      this.files.set(file.id, file);
+    }
+    return accepted;
+  }
+  removeFile(id) {
+    const file = this.files.get(id);
+    if (file) {
+      revokeObjectUrl(file);
+      this.files.delete(id);
+    }
+    return file;
+  }
+  replaceFile(id, file) {
+    const current = this.files.get(id);
+    if (!current) {
+      throw new UpupError(
+        `replaceFile: unknown file ID "${id}"`,
+        "BAD_REQUEST" /* BAD_REQUEST */
+      );
+    }
+    const next = "metadata" in file && "source" in file && "status" in file ? Object.assign(file, { id }) : Object.assign(nativeToUploadFile(file, current.source), {
+      id
+    });
+    if (current.url !== next.url) {
+      revokeObjectUrl(current);
+    }
+    this.files.set(id, next);
+    return next;
+  }
+  removeAll() {
+    for (const file of this.files.values()) {
+      revokeObjectUrl(file);
+    }
+    this.files.clear();
+  }
+  /** Bulk-apply pipeline-produced files (already UploadFile with status/key set). */
+  applyProcessed(files) {
+    for (const file of files) {
+      this.files.set(file.id, file);
+    }
+  }
+  /** Re-instate a prior snapshot: clear and repopulate from entries. */
+  restore(entries) {
+    this.files.clear();
+    for (const [id, file] of entries) {
+      this.files.set(id, file);
+    }
+  }
+  async setFiles(nativeFiles) {
+    const acceptedNativeFiles = await this.collectAcceptedFiles(nativeFiles);
+    const dedupedFiles = await this.deduplicateByContent(
+      acceptedNativeFiles,
+      []
+    );
+    this.assertBatchFits(
+      dedupedFiles.map((item) => item.file),
+      [],
+      nativeFiles[0]
+    );
+    const accepted = dedupedFiles.map(({ file, hash }) => {
+      const uploadFile = nativeToUploadFile(file);
+      return hash ? applyContentHash(uploadFile, hash) : uploadFile;
+    });
+    for (const file of this.files.values()) {
+      revokeObjectUrl(file);
+    }
+    this.files.clear();
+    for (const file of accepted) {
+      this.files.set(file.id, file);
+    }
+    return accepted;
+  }
+  reorderFiles(fileIds) {
+    if (fileIds.length !== this.files.size) {
+      throw new UpupError(
+        `reorderFiles: expected ${this.files.size} IDs but received ${fileIds.length}`,
+        "BAD_REQUEST" /* BAD_REQUEST */
+      );
+    }
+    const newMap = /* @__PURE__ */ new Map();
+    for (const id of fileIds) {
+      const file = this.files.get(id);
+      if (!file) {
+        throw new UpupError(
+          `reorderFiles: unknown file ID "${id}"`,
+          "BAD_REQUEST" /* BAD_REQUEST */
+        );
+      }
+      newMap.set(id, file);
+    }
+    this.files = newMap;
+  }
+};
+
+// src/upload-manager.ts
+var UpupUploadBatchError = class extends Error {
+  constructor(message, errors) {
+    super(message);
+    this.name = "UpupUploadBatchError";
+    this.errors = errors;
+  }
+};
+var UploadManager = class {
+  constructor(options) {
+    this.abortController = new AbortController();
+    this.options = options;
+  }
+  async uploadAll(files) {
+    const { maxConcurrentUploads } = this.options;
+    const results = [];
+    const errors = [];
+    const queue = [...files];
+    let active = 0;
+    await new Promise((resolve) => {
+      const tryNext = () => {
+        if (queue.length === 0 && active === 0) {
+          resolve();
+          return;
+        }
+        while (active < maxConcurrentUploads && queue.length > 0) {
+          const file = queue.shift();
+          if (!file) break;
+          active++;
+          this.uploadFile(file).then((result) => {
+            results.push(result);
+            this.options.onFileComplete(file, result);
+          }).catch((err) => {
+            const error = err instanceof Error ? err : new Error(String(err));
+            if (this.options.onFileError) {
+              this.options.onFileError(file, error);
+            }
+            errors.push({ file, error });
+          }).finally(() => {
+            active--;
+            tryNext();
+          });
+        }
+      };
+      tryNext();
+      if (files.length === 0) {
+        resolve();
+      }
+    });
+    if (errors.length > 0) {
+      throw new UpupUploadBatchError(
+        `${errors.length} file upload(s) failed`,
+        errors
+      );
+    }
+    return results;
+  }
+  // A method (rather than inlining `this.abortController.signal.aborted`,
+  // or a getter — TS's control-flow narrowing treats a no-setter accessor
+  // like a readonly field) so each call is re-evaluated fresh:
+  // `abortController` can be replaced concurrently by `pause()`/`abort()`
+  // while an attempt is in flight, across the `await`s below.
+  checkAborted() {
+    return this.abortController.signal.aborted;
+  }
+  async uploadFile(file) {
+    const {
+      credentials,
+      uploadStrategy,
+      maxRetries = 3,
+      isSuccessfulCall
+    } = this.options;
+    const maxAttempts = maxRetries + 1;
+    let lastError = null;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      if (this.checkAborted()) {
+        throw new UpupNetworkError("Upload aborted");
+      }
+      try {
+        this.options.onFileStart?.(file);
+        const plan = this.options.resolveUploadStrategy?.(file) ?? {
+          uploadStrategy,
+          presign: true
+        };
+        const currentMetadata = file.metadata;
+        const metadata = {
+          ...currentMetadata,
+          ...file.relativePath && currentMetadata.relativePath == null ? { relativePath: file.relativePath } : {}
+        };
+        const fileMetadata = {
+          name: file.name,
+          size: file.size,
+          type: file.type,
+          metadata
+        };
+        const presigned = plan.presign ? await credentials.getPresignedUrl(fileMetadata) : {
+          key: file.id,
+          uploadUrl: "",
+          expiresIn: 0
+        };
+        const result = await plan.uploadStrategy.upload(
+          file,
+          presigned,
+          {
+            onProgress: (loaded, total) => {
+              this.options.onProgress(file.id, loaded, total);
+            },
+            signal: this.abortController.signal
+          }
+        );
+        if (isSuccessfulCall) {
+          const syntheticResponse = {
+            status: 200,
+            headers: {},
+            body: result
+          };
+          const ok = await isSuccessfulCall(syntheticResponse);
+          if (!ok) {
+            throw new UpupNetworkError(
+              "isSuccessfulCall returned false",
+              0
+            );
+          }
+        }
+        return result;
+      } catch (err) {
+        if (this.checkAborted()) {
+          throw err;
+        }
+        const isNetwork = err instanceof UpupNetworkError;
+        if (isNetwork && err.status !== void 0 && err.status >= 400 && err.status < 500) {
+          throw err;
+        }
+        if (isNetwork && err.status === 0) {
+          throw err;
+        }
+        lastError = err instanceof Error ? err : new Error(String(err));
+        if (attempt < maxAttempts - 1) {
+          await new Promise(
+            (r) => setTimeout(r, 100 * Math.pow(2, attempt))
+          );
+        }
+      }
+    }
+    const finalError = lastError ?? new UpupNetworkError("Upload failed after retries");
+    throw finalError;
+  }
+  abort() {
+    this.abortController.abort();
+  }
+  pause() {
+    this.abortController.abort();
+    this.abortController = new AbortController();
+  }
+};
+
+// src/utils/status-helpers.ts
+function isUploadActive(status) {
+  return status === "UPLOADING" /* UPLOADING */ || status === "PROCESSING" /* PROCESSING */;
+}
+function isUploadIdle(status) {
+  return status === "IDLE" /* IDLE */ || status === "READY" /* READY */;
+}
+function isFileRemovalLocked(progress, fileStatus) {
+  return !!progress && fileStatus !== "PAUSED" /* PAUSED */;
+}
+
+// src/crash-recovery.ts
+var STORAGE_KEY = "upup-crash-recovery";
+var CrashRecoveryManager = class {
+  constructor(storage) {
+    this.storage = storage;
+  }
+  async save(snapshot) {
+    await this.storage.set(STORAGE_KEY, snapshot);
+  }
+  async restore() {
+    const data = await this.storage.get(STORAGE_KEY);
+    return data ?? null;
+  }
+  async clear() {
+    await this.storage.delete(STORAGE_KEY);
+  }
+};
+var IndexedDBStorage = class {
+  constructor(dbName = "upup-crash-recovery") {
+    this.storeName = "upup-store";
+    /** 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. */
+    this.dbPromise = null;
+    this.dbName = dbName;
+  }
+  getDB() {
+    if (this.dbPromise) return this.dbPromise;
+    const promise = new Promise((resolve, reject) => {
+      const request = indexedDB.open(this.dbName, 1);
+      request.onupgradeneeded = () => {
+        request.result.createObjectStore(this.storeName);
+      };
+      request.onsuccess = () => {
+        const db = request.result;
+        db.onversionchange = () => {
+          db.close();
+          if (this.dbPromise === promise) {
+            this.dbPromise = null;
+          }
+        };
+        db.onclose = () => {
+          if (this.dbPromise === promise) {
+            this.dbPromise = null;
+          }
+        };
+        resolve(db);
+      };
+      request.onerror = () => {
+        if (this.dbPromise === promise) {
+          this.dbPromise = null;
+        }
+        reject(request.error ?? new Error("IndexedDB open failed"));
+      };
+    });
+    this.dbPromise = promise;
+    return promise;
+  }
+  /** 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() {
+    const promise = this.dbPromise;
+    if (!promise) return;
+    this.dbPromise = null;
+    void promise.then(
+      (db) => {
+        db.close();
+      },
+      () => {
+      }
+    );
+  }
+  async get(key) {
+    try {
+      const db = await this.getDB();
+      return await new Promise((resolve, reject) => {
+        const tx = db.transaction(this.storeName, "readonly");
+        const store = tx.objectStore(this.storeName);
+        const request = store.get(key);
+        request.onsuccess = () => {
+          resolve(request.result);
+        };
+        request.onerror = () => {
+          reject(request.error ?? new Error("IndexedDB get failed"));
+        };
+      });
+    } catch {
+      return void 0;
+    }
+  }
+  async set(key, value) {
+    try {
+      const db = await this.getDB();
+      await new Promise((resolve, reject) => {
+        const tx = db.transaction(this.storeName, "readwrite");
+        const store = tx.objectStore(this.storeName);
+        const request = store.put(value, key);
+        request.onsuccess = () => {
+          resolve();
+        };
+        request.onerror = () => {
+          reject(request.error ?? new Error("IndexedDB put failed"));
+        };
+      });
+    } catch {
+    }
+  }
+  async delete(key) {
+    try {
+      const db = await this.getDB();
+      await new Promise((resolve, reject) => {
+        const tx = db.transaction(this.storeName, "readwrite");
+        const store = tx.objectStore(this.storeName);
+        const request = store.delete(key);
+        request.onsuccess = () => {
+          resolve();
+        };
+        request.onerror = () => {
+          reject(
+            request.error ?? new Error("IndexedDB delete failed")
+          );
+        };
+      });
+    } catch {
+    }
+  }
+};
+
+// src/drives/pkce.ts
+function generateCodeVerifier(length = 128) {
+  const charset = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~";
+  const values = crypto.getRandomValues(new Uint8Array(length));
+  return Array.from(values, (b) => charset[b % charset.length]).join("");
+}
+async function generateCodeChallenge(verifier) {
+  const data = new TextEncoder().encode(verifier);
+  const digest = await crypto.subtle.digest("SHA-256", data);
+  return btoa(String.fromCharCode(...new Uint8Array(digest))).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+
+// src/drives/session-storage.ts
+function storageGet(key) {
+  if (typeof window === "undefined") return null;
+  try {
+    return sessionStorage.getItem(key);
+  } catch {
+    return null;
+  }
+}
+function storageSet(key, value) {
+  if (typeof window === "undefined") return;
+  try {
+    sessionStorage.setItem(key, value);
+  } catch {
+  }
+}
+function storageDel(key) {
+  if (typeof window === "undefined") return;
+  try {
+    sessionStorage.removeItem(key);
+  } catch {
+  }
+}
+
+// src/drives/popup-oauth-plugin.ts
+var PopupOAuthPlugin = class {
+  constructor() {
+    this.emitter = null;
+    this.config = { clientId: "" };
+    this.accessToken = null;
+    this.refreshTokenValue = null;
+    this.tokenExpiry = 0;
+    this.state = "idle";
+    this.codeVerifier = null;
+    // Popup polling references
+    this.popupWindow = null;
+    this.pollTimer = null;
+  }
+  get id() {
+    return this.spec.id;
+  }
+  get name() {
+    return this.spec.id;
+  }
+  // ── Plugin lifecycle ──
+  configure(config) {
+    this.config = config;
+    return this;
+  }
+  getConfig() {
+    return this.config;
+  }
+  init(emitter) {
+    this.emitter = emitter;
+  }
+  destroy() {
+    this.cleanupPopup();
+    this.emitter = null;
+  }
+  // ── State management ──
+  getState() {
+    return this.state;
+  }
+  setState(newState) {
+    this.state = newState;
+    this.emitter?.emit(`${this.spec.eventPrefix}:state-change`, {
+      state: newState
+    });
+  }
+  // ── Auth: build the OAuth URL with PKCE ──
+  async getAuthUrl() {
+    const clientId = this.config.clientId;
+    if (!clientId) {
+      throw new UpupAuthError(
+        `${this.spec.displayName} client_id is not configured`,
+        this.spec.displayName
+      );
+    }
+    const redirectUri = this.getRedirectUri();
+    this.codeVerifier = generateCodeVerifier();
+    const challenge = await generateCodeChallenge(this.codeVerifier);
+    const params = new URLSearchParams({
+      client_id: clientId,
+      response_type: "code",
+      redirect_uri: redirectUri,
+      code_challenge: challenge,
+      code_challenge_method: "S256",
+      ...this.spec.authParams ?? {}
+    });
+    if (this.spec.scopes) {
+      params.set("scope", this.spec.scopes);
+    }
+    return `${this.spec.authUrl}?${params.toString()}`;
+  }
+  // ── Auth: exchange authorization code for tokens ──
+  async authenticate(code) {
+    const clientId = this.config.clientId;
+    if (!clientId) {
+      throw new UpupAuthError(
+        `${this.spec.displayName} client_id is not configured`,
+        this.spec.displayName
+      );
+    }
+    if (!this.codeVerifier) {
+      throw new UpupAuthError(
+        "No PKCE code verifier \u2014 call getAuthUrl() first",
+        this.spec.displayName
+      );
+    }
+    this.setState("authenticating");
+    try {
+      const body = new URLSearchParams({
+        code,
+        client_id: clientId,
+        code_verifier: this.codeVerifier,
+        grant_type: "authorization_code",
+        redirect_uri: this.getRedirectUri()
+      });
+      if (this.spec.scopes) {
+        body.set("scope", this.spec.scopes);
+      }
+      const res = await fetch(this.spec.tokenUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded"
+        },
+        body
+      });
+      if (!res.ok) {
+        const text = await res.text();
+        throw new UpupAuthError(
+          `Token exchange failed: ${text}`,
+          this.spec.displayName
+        );
+      }
+      const data = await res.json();
+      this.setTokens(
+        data.access_token,
+        data.refresh_token ?? null,
+        data.expires_in
+      );
+      let user;
+      try {
+        user = await this.fetchUserProfile();
+      } catch {
+      }
+      this.setState("authenticated");
+      this.emitter?.emit(`${this.spec.eventPrefix}:authenticated`, {
+        user
+      });
+    } catch (err) {
+      this.setState("idle");
+      this.emitter?.emit(`${this.spec.eventPrefix}:error`, {
+        error: err instanceof Error ? err : new Error(String(err)),
+        action: "authenticate"
+      });
+      throw err;
+    }
+  }
+  // ── Auth: popup-based flow (open popup, poll for redirect code) ──
+  async authenticateViaPopup() {
+    if (typeof window === "undefined") {
+      throw new UpupAuthError(
+        "authenticateViaPopup requires a browser environment",
+        this.spec.displayName
+      );
+    }
+    const url = await this.getAuthUrl();
+    this.cleanupPopup();
+    const left = (typeof window !== "undefined" ? window.screenX : 0) + 60;
+    const top = (typeof window !== "undefined" ? window.screenY : 0) + 60;
+    this.popupWindow = window.open(
+      url,
+      this.spec.popupName,
+      `width=800,height=600,left=${left},top=${top},toolbar=0,scrollbars=1,status=1,resizable=1`
+    );
+    if (!this.popupWindow) {
+      this.emitter?.emit(`${this.spec.eventPrefix}:error`, {
+        error: new Error("Popup was blocked by the browser"),
+        action: "authenticateViaPopup"
+      });
+      throw new UpupAuthError(
+        "Popup was blocked by the browser",
+        this.spec.displayName
+      );
+    }
+    this.setState("authenticating");
+    return new Promise((resolve, reject) => {
+      const redirectUri = this.getRedirectUri();
+      this.pollTimer = setInterval(() => {
+        void (async () => {
+          try {
+            if (!this.popupWindow || this.popupWindow.closed) {
+              this.cleanupPopup();
+              this.setState("idle");
+              resolve();
+              return;
+            }
+            let href;
+            try {
+              href = this.popupWindow.location.href;
+            } catch {
+              return;
+            }
+            if (!href.startsWith(redirectUri) || !href.includes("code=")) {
+              return;
+            }
+            this.cleanupPollTimer();
+            const code = new URL(href).searchParams.get("code");
+            this.popupWindow.close();
+            this.popupWindow = null;
+            if (!code) {
+              const err = new Error(
+                "No authorization code found in redirect URL"
+              );
+              this.setState("idle");
+              this.emitter?.emit(
+                `${this.spec.eventPrefix}:error`,
+                {
+                  error: err,
+                  action: "authenticateViaPopup"
+                }
+              );
+              reject(err);
+              return;
+            }
+            await this.authenticate(code);
+            resolve();
+          } catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            if (message.includes("cross-origin") || message.includes("Cross-Origin") || message.includes("Permission denied") || message.includes("Failed to read")) {
+              return;
+            }
+            this.cleanupPopup();
+            this.setState("idle");
+            this.emitter?.emit(`${this.spec.eventPrefix}:error`, {
+              error: err instanceof Error ? err : new Error(String(err)),
+              action: "authenticateViaPopup"
+            });
+            reject(err instanceof Error ? err : new Error(message));
+          }
+        })();
+      }, 500);
+    });
+  }
+  // ── Auth: refresh access token ──
+  async refreshAccessToken() {
+    const clientId = this.config.clientId;
+    if (!clientId || !this.refreshTokenValue) return null;
+    try {
+      const body = new URLSearchParams({
+        grant_type: "refresh_token",
+        refresh_token: this.refreshTokenValue,
+        client_id: clientId
+      });
+      if (this.spec.scopes) {
+        body.set("scope", this.spec.scopes);
+      }
+      const res = await fetch(this.spec.tokenUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded"
+        },
+        body
+      });
+      if (!res.ok) {
+        const text = await res.text();
+        throw new UpupAuthError(
+          `Token refresh failed: ${text}`,
+          this.spec.displayName
+        );
+      }
+      const data = await res.json();
+      this.setTokens(
+        data.access_token,
+        data.refresh_token ?? this.refreshTokenValue,
+        data.expires_in
+      );
+      return data.access_token;
+    } catch (err) {
+      this.emitter?.emit(`${this.spec.eventPrefix}:session-expired`, {});
+      this.emitter?.emit(`${this.spec.eventPrefix}:error`, {
+        error: err instanceof Error ? err : new Error(String(err)),
+        action: "refreshAccessToken"
+      });
+      this.clearTokens();
+      this.setState("session-expired");
+      return null;
+    }
+  }
+  // ── Auth: sign out ──
+  signOut() {
+    this.clearTokens();
+    this.cleanupPopup();
+    this.setState("idle");
+    this.emitter?.emit(`${this.spec.eventPrefix}:signed-out`, {});
+  }
+  // ── Auth: restore session from sessionStorage ──
+  restoreSession() {
+    const token = storageGet(this.spec.storageKeys.access);
+    const refresh = storageGet(this.spec.storageKeys.refresh);
+    const expiry = storageGet(this.spec.storageKeys.expiry);
+    if (!token) return false;
+    this.accessToken = token;
+    this.refreshTokenValue = refresh;
+    this.tokenExpiry = expiry ? parseInt(expiry, 10) : 0;
+    this.setState("authenticated");
+    return true;
+  }
+  // ── Auth helpers ──
+  isAuthenticated() {
+    return this.state === "authenticated" && this.accessToken !== null;
+  }
+  getAccessToken() {
+    return this.accessToken;
+  }
+  // Guarded public entry point the controller drives (F-123): swallow-to-null
+  // instead of throwing, so a failed profile fetch never strands the restore
+  // flow in an unhandled rejection. Requires isAuthenticated() — unlike
+  // authenticate()'s internal call, which fetches before the flag flips.
+  async getUserInfo() {
+    if (!this.isAuthenticated()) return null;
+    try {
+      return await this.fetchUserProfile();
+    } catch {
+      return null;
+    }
+  }
+  // ── Private: authenticated API request with proactive + reactive refresh ──
+  async apiRequest(url, options, isRetry = false) {
+    await this.ensureValidToken();
+    const headers = new Headers(options.headers ?? {});
+    headers.set("Authorization", `Bearer ${this.accessToken}`);
+    const res = await fetch(url, { ...options, headers });
+    if (res.ok) return res;
+    const errorText = await res.text();
+    if (res.status === 401 && !isRetry) {
+      if (this.refreshTokenValue) {
+        const newToken = await this.refreshAccessToken();
+        if (newToken) {
+          return this.apiRequest(url, options, true);
+        }
+      }
+      this.emitter?.emit(`${this.spec.eventPrefix}:session-expired`, {});
+      this.clearTokens();
+      this.setState("session-expired");
+    }
+    throw new UpupNetworkError(
+      `${this.spec.displayName} API error (${res.status}): ${errorText}`,
+      res.status
+    );
+  }
+  // ── Private: token management ──
+  setTokens(access, refresh, expiresIn) {
+    this.accessToken = access;
+    this.refreshTokenValue = refresh;
+    this.tokenExpiry = expiresIn ? Date.now() + expiresIn * 1e3 : 0;
+    storageSet(this.spec.storageKeys.access, access);
+    if (refresh) storageSet(this.spec.storageKeys.refresh, refresh);
+    if (this.tokenExpiry) {
+      storageSet(this.spec.storageKeys.expiry, String(this.tokenExpiry));
+    }
+  }
+  clearTokens() {
+    this.accessToken = null;
+    this.refreshTokenValue = null;
+    this.tokenExpiry = 0;
+    storageDel(this.spec.storageKeys.access);
+    storageDel(this.spec.storageKeys.refresh);
+    storageDel(this.spec.storageKeys.expiry);
+  }
+  async ensureValidToken() {
+    if (!this.accessToken) {
+      throw new UpupAuthError(
+        "Not authenticated \u2014 no access token",
+        this.spec.displayName
+      );
+    }
+    if (this.tokenExpiry > 0 && Date.now() > this.tokenExpiry - 6e4 && this.refreshTokenValue) {
+      await this.refreshAccessToken();
+    }
+  }
+  // ── Private: redirect URI ──
+  getRedirectUri() {
+    if (this.config.redirectUri) {
+      return this.config.redirectUri;
+    }
+    if (typeof window !== "undefined") {
+      return `${window.location.origin}${this.spec.redirectPath}`;
+    }
+    return "";
+  }
+  // ── Private: popup cleanup ──
+  cleanupPopup() {
+    this.cleanupPollTimer();
+    if (this.popupWindow && !this.popupWindow.closed) {
+      this.popupWindow.close();
+    }
+    this.popupWindow = null;
+  }
+  cleanupPollTimer() {
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+  }
+};
+
+// src/drives/mime.ts
+function guessMimeType(name) {
+  if (!name) return "application/octet-stream";
+  const ext = name.split(".").pop()?.toLowerCase() ?? "";
+  const map = {
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    png: "image/png",
+    gif: "image/gif",
+    webp: "image/webp",
+    svg: "image/svg+xml",
+    pdf: "application/pdf",
+    doc: "application/msword",
+    docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    xls: "application/vnd.ms-excel",
+    xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    ppt: "application/vnd.ms-powerpoint",
+    pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    txt: "text/plain",
+    csv: "text/csv",
+    json: "application/json",
+    xml: "application/xml",
+    zip: "application/zip",
+    mp3: "audio/mpeg",
+    mp4: "video/mp4",
+    mov: "video/quicktime",
+    avi: "video/x-msvideo",
+    html: "text/html",
+    css: "text/css",
+    js: "application/javascript",
+    ts: "application/typescript"
+  };
+  return map[ext] ?? "application/octet-stream";
+}
+
+// src/drives/dropbox-plugin.ts
+var AUTH_URL = "https://www.dropbox.com/oauth2/authorize";
+var TOKEN_URL = "https://api.dropbox.com/oauth2/token";
+var LIST_FOLDER_URL = "https://api.dropbox.com/2/files/list_folder";
+var LIST_FOLDER_CONTINUE_URL = "https://api.dropbox.com/2/files/list_folder/continue";
+var SEARCH_URL = "https://api.dropbox.com/2/files/search_v2";
+var USER_INFO_URL = "https://api.dropbox.com/2/users/get_current_account";
+var TEMP_LINK_URL = "https://api.dropbox.com/2/files/get_temporary_link";
+var OAUTH_SCOPES = "files.metadata.read files.content.read files.content.write account_info.read";
+function mapEntry(entry) {
+  const tag = entry[".tag"];
+  const isFolder = tag === "folder";
+  return {
+    id: entry.id ?? "",
+    name: entry.name ?? "",
+    path: entry.path_display ?? "",
+    size: isFolder ? 0 : entry.size ?? 0,
+    mimeType: isFolder ? "folder" : guessMimeType(entry.name),
+    isFolder,
+    thumbnail: void 0,
+    modifiedAt: entry.server_modified ?? void 0
+  };
+}
+var DropboxPlugin = class extends PopupOAuthPlugin {
+  constructor() {
+    super(...arguments);
+    this.spec = {
+      id: "dropbox",
+      displayName: "Dropbox",
+      eventPrefix: "dropbox",
+      popupName: "UpupDropboxAuth",
+      authUrl: AUTH_URL,
+      tokenUrl: TOKEN_URL,
+      redirectPath: "/dp_redirect",
+      storageKeys: {
+        access: "upup_dropbox_access_token",
+        refresh: "upup_dropbox_refresh_token",
+        expiry: "upup_dropbox_token_expiry"
+      },
+      scopes: OAUTH_SCOPES,
+      authParams: { token_access_type: "offline" }
+    };
+  }
+  configure(config) {
+    return super.configure(config);
+  }
+  getConfig() {
+    return this.config;
+  }
+  // ── File operations: list folder ──
+  async loadFiles(path = "") {
+    this.setState("browsing");
+    try {
+      const res = await this.apiRequest(LIST_FOLDER_URL, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          path,
+          recursive: false,
+          include_media_info: true,
+          include_deleted: false,
+          include_has_explicit_shared_members: false
+        })
+      });
+      const data = await res.json();
+      const files = (data.entries ?? []).map(mapEntry);
+      this.setState("authenticated");
+      this.emitter?.emit("dropbox:files-loaded", {
+        files,
+        path,
+        hasMore: !!data.has_more,
+        cursor: data.cursor
+      });
+      return {
+        files,
+        hasMore: !!data.has_more,
+        ...data.cursor !== void 0 ? { cursor: data.cursor } : {}
+      };
+    } catch (err) {
+      this.setState("authenticated");
+      this.emitter?.emit("dropbox:error", {
+        error: err instanceof Error ? err : new Error(String(err)),
+        action: "loadFiles"
+      });
+      throw err;
+    }
+  }
+  // ── File operations: continue listing (pagination) ──
+  async loadMoreFiles(cursor) {
+    try {
+      const res = await this.apiRequest(LIST_FOLDER_CONTINUE_URL, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ cursor })
+      });
+      const data = await res.json();
+      const files = (data.entries ?? []).map(mapEntry);
+      return {
+        files,
+        hasMore: !!data.has_more,
+        ...data.cursor !== void 0 ? { cursor: data.cursor } : {}
+      };
+    } catch (err) {
+      this.emitter?.emit("dropbox:error", {
+        error: err instanceof Error ? err : new Error(String(err)),
+        action: "loadMoreFiles"
+      });
+      throw err;
+    }
+  }
+  // ── File operations: load all files in folder recursively ──
+  async loadAllFilesInFolder(folderPath) {
+    const allFiles = [];
+    try {
+      const initialRes = await this.apiRequest(LIST_FOLDER_URL, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          path: folderPath,
+          recursive: true,
+          include_media_info: true
+        })
+      });
+      let data = await initialRes.json();
+      const entries = data.entries ?? [];
+      while (data.has_more) {
+        const contRes = await this.apiRequest(
+          LIST_FOLDER_CONTINUE_URL,
+          {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ cursor: data.cursor })
+          }
+        );
+        data = await contRes.json();
+        entries.push(...data.entries ?? []);
+      }
+      for (const entry of entries) {
+        const file = mapEntry(entry);
+        if (!file.isFolder) allFiles.push(file);
+      }
+      return allFiles;
+    } catch (err) {
+      this.emitter?.emit("dropbox:error", {
+        error: err instanceof Error ? err : new Error(String(err)),
+        action: "loadAllFilesInFolder"
+      });
+      throw err;
+    }
+  }
+  // ── File operations: download files ──
+  async downloadFiles(driveFiles) {
+    const results = [];
+    for (const driveFile of driveFiles) {
+      if (driveFile.isFolder) continue;
+      try {
+        const file = await this.downloadSingleFile(driveFile);
+        if (file) {
+          results.push(file);
+        }
+      } catch (err) {
+        this.emitter?.emit("dropbox:error", {
+          error: err instanceof Error ? err : new Error(String(err)),
+          action: "downloadFiles"
+        });
+      }
+    }
+    return results;
+  }
+  // ── File operations: search ──
+  async searchFiles(query, path) {
+    try {
+      const body = {
+        query,
+        options: {
+          max_results: 100,
+          file_status: { ".tag": "active" }
+        }
+      };
+      if (path) {
+        body.options = {
+          ...body.options,
+          path
+        };
+      }
+      const res = await this.apiRequest(SEARCH_URL, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body)
+      });
+      const data = await res.json();
+      const matches = data.matches ?? [];
+      return matches.map((m) => mapEntry(m.metadata.metadata));
+    } catch (err) {
+      this.emitter?.emit("dropbox:error", {
+        error: err instanceof Error ? err : new Error(String(err)),
+        action: "searchFiles"
+      });
+      throw err;
+    }
+  }
+  // ── Provider hooks required by the base ──
+  mapEntry(entry) {
+    return mapEntry(entry);
+  }
+  // ── Private: download a single file via temporary link ──
+  async downloadSingleFile(driveFile) {
+    const linkRes = await this.apiRequest(TEMP_LINK_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ path: driveFile.path })
+    });
+    const linkData = await linkRes.json();
+    const downloadLink = linkData.link;
+    if (!downloadLink) {
+      throw new UpupNetworkError(
+        `No download link returned for ${driveFile.name}`
+      );
+    }
+    const downloadRes = await fetch(downloadLink, { method: "GET" });
+    if (!downloadRes.ok) {
+      throw new UpupNetworkError(
+        `Download failed (${downloadRes.status}) for ${driveFile.name}`,
+        downloadRes.status
+      );
+    }
+    const blob = await downloadRes.blob();
+    return new File([blob], driveFile.name, {
+      type: blob.type || driveFile.mimeType || "application/octet-stream"
+    });
+  }
+  // ── Private: fetch user profile ──
+  async fetchUserProfile() {
+    const res = await this.apiRequest(USER_INFO_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: null
+    });
+    const data = await res.json();
+    return {
+      name: data.name?.display_name ?? "",
+      email: data.email ?? ""
+    };
+  }
+};
+
+// src/drives/google-drive-plugin.ts
+var SK_ACCESS = "upup_gdrive_access_token";
+var SK_EXPIRY = "upup_gdrive_token_expiry";
+var FILES_URL = "https://www.googleapis.com/drive/v3/files";
+var USER_INFO_URL2 = "https://www.googleapis.com/oauth2/v3/userinfo";
+var WORKSPACE_EXPORT_MAP = {
+  "application/vnd.google-apps.document": {
+    exportMime: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    ext: "docx",
+    docType: "document"
+  },
+  "application/vnd.google-apps.spreadsheet": {
+    exportMime: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    ext: "xlsx",
+    docType: "spreadsheets"
+  },
+  "application/vnd.google-apps.presentation": {
+    exportMime: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+    ext: "pptx",
+    docType: "presentation"
+  },
+  "application/vnd.google-apps.drawing": {
+    exportMime: "image/png",
+    ext: "png",
+    docType: "drawings"
+  }
+};
+var FORMAT_MAP = {
+  docx: "docx",
+  xlsx: "xlsx",
+  pptx: "pptx",
+  png: "png"
+};
+function isWorkspaceFile(mimeType) {
+  return mimeType in WORKSPACE_EXPORT_MAP;
+}
+function getExportUrl(fileId, mimeType) {
+  const mapping = WORKSPACE_EXPORT_MAP[mimeType];
+  if (!mapping) return null;
+  const format = FORMAT_MAP[mapping.ext];
+  return `https://docs.google.com/${mapping.docType}/d/${fileId}/export?format=${format}`;
+}
+function mapGoogleEntry(entry) {
+  const mimeType = entry.mimeType ?? "";
+  const isFolder = mimeType === "application/vnd.google-apps.folder";
+  return {
+    id: entry.id ?? "",
+    name: entry.name ?? "",
+    path: "",
+    // Google Drive doesn't return a path, uses parent IDs
+    size: isFolder ? 0 : typeof entry.size === "number" ? entry.size : typeof entry.size === "string" ? parseInt(entry.size, 10) || 0 : 0,
+    mimeType: isFolder ? "folder" : mimeType,
+    isFolder,
+    thumbnail: entry.thumbnailLink ?? void 0,
+    modifiedAt: void 0
+  };
+}
+var GoogleDrivePlugin = class {
+  constructor() {
+    this.id = "google-drive";
+    this.name = "google-drive";
+    this.emitter = null;
+    this.config = {
+      apiKey: "",
+      appId: "",
+      clientId: ""
+    };
+    this.accessToken = null;
+    this.tokenExpiry = 0;
+    this.state = "idle";
+  }
+  // ── Plugin lifecycle ──
+  configure(config) {
+    this.config = config;
+    return this;
+  }
+  getConfig() {
+    return this.config;
+  }
+  init(emitter) {
+    this.emitter = emitter;
+  }
+  destroy() {
+    this.emitter = null;
+  }
+  // ── State management ──
+  getState() {
+    return this.state;
+  }
+  setState(newState) {
+    this.state = newState;
+    this.emitter?.emit("google-drive:state-change", { state: newState });
+  }
+  // ── Auth: accept token from GIS popup (called by React thin hook) ──
+  setAccessToken(token, expiresIn) {
+    const expiry = expiresIn ? Date.now() + expiresIn * 1e3 : 0;
+    this.accessToken = token;
+    this.tokenExpiry = expiry;
+    storageSet(SK_ACCESS, token);
+    if (expiry) storageSet(SK_EXPIRY, String(expiry));
+    this.setState("authenticated");
+  }
+  // ── Auth: authenticate with token + fetch user info ──
+  async authenticate(token, expiresIn) {
+    this.setState("authenticating");
+    try {
+      this.setAccessToken(token, expiresIn);
+      let user;
+      try {
+        user = await this.getUserInfo();
+      } catch {
+      }
+      this.setState("authenticated");
+      this.emitter?.emit("google-drive:authenticated", { user });
+    } catch (err) {
+      this.setState("idle");
+      this.emitter?.emit("google-drive:error", {
+        error: err instanceof Error ? err : new Error(String(err)),
+        action: "authenticate"
+      });
+      throw err;
+    }
+  }
+  // ── Auth: sign out ──
+  signOut() {
+    this.clearTokens();
+    this.setState("idle");
+    this.emitter?.emit("google-drive:signed-out", {});
+  }
+  // ── Auth: restore session from sessionStorage ──
+  restoreSession() {
+    const token = storageGet(SK_ACCESS);
+    const expiry = storageGet(SK_EXPIRY);
+    if (!token) return false;
+    this.accessToken = token;
+    this.tokenExpiry = expiry ? parseInt(expiry, 10) : 0;
+    if (this.tokenExpiry > 0 && Date.now() > this.tokenExpiry) {
+      this.clearTokens();
+      this.emitter?.emit("google-drive:session-expired", {});
+      this.setState("session-expired");
+      return false;
+    }
+    this.setState("authenticated");
+    return true;
+  }
+  // ── Auth helpers ──
+  isAuthenticated() {
+    return this.state === "authenticated" && this.accessToken !== null;
+  }
+  getAccessToken() {
+    return this.accessToken;
+  }
+  // ── User info ──
+  async getUserInfo() {
+    const res = await this.apiRequest(USER_INFO_URL2, { method: "GET" });
+    const data = await res.json();
+    return {
+      name: data.name ?? "",
+      email: data.email ?? "",
+      ...data.picture !== void 0 ? { picture: data.picture } : {}
+    };
+  }
+  // ── File operations: list files ──
+  async loadFiles(folderId) {
+    this.setState("browsing");
+    try {
+      const parentId = folderId || "root";
+      const q = `'${parentId}' in parents and trashed = false`;
+      const params = new URLSearchParams({
+        q,
+        fields: "nextPageToken,files(fileExtension,id,mimeType,name,parents,size,thumbnailLink)",
+        key: this.config.apiKey,
+        pageSize: "1000"
+      });
+      const res = await this.apiRequest(
+        `${FILES_URL}?${params.toString()}`,
+        { method: "GET" }
+      );
+      const data = await res.json();
+      const files = (data.files ?? []).map(mapGoogleEntry);
+      const hasMore = !!data.nextPageToken;
+      const cursor = hasMore ? JSON.stringify({
+        folderId: parentId,
+        pageToken: data.nextPageToken
+      }) : void 0;
+      this.setState("authenticated");
+      this.emitter?.emit("google-drive:files-loaded", {
+        files,
+        folderId: parentId,
+        hasMore,
+        cursor
+      });
+      return {
+        files,
+        folderId: parentId,
+        hasMore,
+        ...cursor !== void 0 ? { cursor } : {}
+      };
+    } catch (err) {
+      this.setState("authenticated");
+      this.emitter?.emit("google-drive:error", {
+        error: err instanceof Error ? err : new Error(String(err)),
+        action: "loadFiles"
+      });
+      throw err;
+    }
+  }
+  // ── File operations: continue listing (pagination) ──
+  async loadMoreFiles(cursor) {
+    try {
+      const { folderId, pageToken } = JSON.parse(cursor);
+      const q = `'${folderId}' in parents and trashed = false`;
+      const params = new URLSearchParams({
+        q,
+        fields: "nextPageToken,files(fileExtension,id,mimeType,name,parents,size,thumbnailLink)",
+        key: this.config.apiKey,
+        pageSize: "1000",
+        pageToken
+      });
+      const res = await this.apiRequest(
+        `${FILES_URL}?${params.toString()}`,
+        { method: "GET" }
+      );
+      const data = await res.json();
+      const files = (data.files ?? []).map(mapGoogleEntry);
+      const hasMore = !!data.nextPageToken;
+      const nextCursor = hasMore ? JSON.stringify({ folderId, pageToken: data.nextPageToken }) : void 0;
+      return {
+        files,
+        hasMore,
+        ...nextCursor !== void 0 ? { cursor: nextCursor } : {}
+      };
+    } catch (err) {
+      this.emitter?.emit("google-drive:error", {
+        error: err instanceof Error ? err : new Error(String(err)),
+        action: "loadMoreFiles"
+      });
+      throw err;
+    }
+  }
+  // ── File operations: download multiple files ──
+  async downloadFiles(driveFiles) {
+    const results = [];
+    for (const driveFile of driveFiles) {
+      if (driveFile.isFolder) continue;
+      try {
+        const file = await this.downloadFile(driveFile);
+        if (file) {
+          results.push(file);
+        }
+      } catch (err) {
+        this.emitter?.emit("google-drive:error", {
+          error: err instanceof Error ? err : new Error(String(err)),
+          action: "downloadFiles"
+        });
+      }
+    }
+    return results;
+  }
+  // ── File operations: download single file ──
+  async downloadFile(driveFile) {
+    if (isWorkspaceFile(driveFile.mimeType)) {
+      return this.downloadWorkspaceFile(driveFile);
+    }
+    return this.downloadRegularFile(driveFile);
+  }
+  // ── Private: download regular (non-Workspace) file ──
+  async downloadRegularFile(driveFile) {
+    const params = new URLSearchParams({
+      key: this.config.apiKey,
+      alt: "media"
+    });
+    const res = await this.apiRequest(
+      `${FILES_URL}/${driveFile.id}?${params.toString()}`,
+      { method: "GET" }
+    );
+    const blob = await res.blob();
+    return new File([blob], driveFile.name, {
+      type: blob.type || driveFile.mimeType || "application/octet-stream"
+    });
+  }
+  // ── Private: download Google Workspace file via export ──
+  async downloadWorkspaceFile(driveFile) {
+    const exportUrl = getExportUrl(driveFile.id, driveFile.mimeType);
+    if (!exportUrl) return null;
+    const mapping = WORKSPACE_EXPORT_MAP[driveFile.mimeType];
+    if (!mapping) return null;
+    const res = await this.apiRequest(exportUrl, { method: "GET" });
+    const blob = await res.blob();
+    const baseName = driveFile.name.replace(/\.[^.]+$/, "");
+    const fileName = `${baseName}.${mapping.ext}`;
+    return new File([blob], fileName, {
+      type: mapping.exportMime
+    });
+  }
+  // ── Private: authenticated API request ──
+  async apiRequest(url, options) {
+    this.ensureValidToken();
+    const headers = new Headers(options.headers ?? {});
+    headers.set("Authorization", `Bearer ${this.accessToken}`);
+    const res = await fetch(url, { ...options, headers });
+    if (res.ok) return res;
+    const errorText = await res.text();
+    if (res.status === 401) {
+      this.emitter?.emit("google-drive:session-expired", {});
+      this.clearTokens();
+      this.setState("session-expired");
+    }
+    throw new UpupNetworkError(
+      `Google Drive API error (${res.status}): ${errorText}`,
+      res.status
+    );
+  }
+  // ── Private: token management ──
+  clearTokens() {
+    this.accessToken = null;
+    this.tokenExpiry = 0;
+    storageDel(SK_ACCESS);
+    storageDel(SK_EXPIRY);
+  }
+  ensureValidToken() {
+    if (!this.accessToken) {
+      throw new UpupAuthError(
+        "Not authenticated \u2014 no access token",
+        "Google Drive"
+      );
+    }
+    if (this.tokenExpiry > 0 && Date.now() > this.tokenExpiry) {
+      this.clearTokens();
+      this.emitter?.emit("google-drive:session-expired", {});
+      this.setState("session-expired");
+      throw new UpupAuthError("Access token has expired", "Google Drive");
+    }
+  }
+};
+
+// src/drives/box-plugin.ts
+var AUTH_URL2 = "https://account.box.com/api/oauth2/authorize";
+var TOKEN_URL2 = "https://api.box.com/oauth2/token";
+var USER_URL = "https://api.box.com/2.0/users/me";
+var FOLDERS_URL = "https://api.box.com/2.0/folders";
+var FILES_URL2 = "https://api.box.com/2.0/files";
+var SEARCH_URL2 = "https://api.box.com/2.0/search";
+function mapEntry2(entry) {
+  const type = entry.type;
+  const isFolder = type === "folder";
+  return {
+    id: entry.id ?? "",
+    name: entry.name ?? "",
+    path: entry.id ?? "",
+    // Box uses IDs for navigation, not paths
+    size: isFolder ? 0 : entry.size ?? 0,
+    mimeType: isFolder ? "folder" : guessMimeType(entry.name),
+    isFolder,
+    thumbnail: void 0,
+    modifiedAt: entry.modified_at ?? void 0
+  };
+}
+var BoxPlugin = class extends PopupOAuthPlugin {
+  constructor() {
+    super(...arguments);
+    this.spec = {
+      id: "box",
+      displayName: "Box",
+      eventPrefix: "box",
+      popupName: "UpupBoxAuth",
+      authUrl: AUTH_URL2,
+      tokenUrl: TOKEN_URL2,
+      redirectPath: "/box_redirect",
+      storageKeys: {
+        access: "upup_box_access_token",
+        refresh: "upup_box_refresh_token",
+        expiry: "upup_box_token_expiry"
+      }
+      // Box scopes are configured on the Box app, not sent on the authorize URL.
+    };
+  }
+  configure(config) {
+    return super.configure(config);
+  }
+  getConfig() {
+    return this.config;
+  }
+  // ── File operations: list folder ──
+  async loadFiles(folderId = "0", offset = "0") {
+    this.setState("browsing");
+    try {
+      const params = new URLSearchParams({
+        fields: "id,name,type,size,modified_at",
+        limit: "1000",
+        offset
+      });
+      const res = await this.apiRequest(
+        `${FOLDERS_URL}/${folderId}/items?${params.toString()}`,
+        { method: "GET" }
+      );
+      const data = await res.json();
+      const files = (data.entries ?? []).map(mapEntry2);
+      const off = Number(data.offset ?? offset);
+      const loaded = off + files.length;
+      const hasMore = loaded < (data.total_count ?? loaded);
+      const cursor = hasMore ? `${folderId}:${loaded}` : void 0;
+      this.setState("authenticated");
+      this.emitter?.emit("box:files-loaded", {
+        files,
+        folderId,
+        hasMore,
+        cursor
+      });
+      return {
+        files,
+        folderId,
+        hasMore,
+        ...cursor !== void 0 ? { cursor } : {}
+      };
+    } catch (err) {
+      this.setState("authenticated");
+      this.emitter?.emit("box:error", {
+        error: err instanceof Error ? err : new Error(String(err)),
+        action: "loadFiles"
+      });
+      throw err;
+    }
+  }
+  // ── File operations: continue listing (pagination) ──
+  async loadMoreFiles(cursor) {
+    const [folderId, offsetStr] = cursor.split(":");
+    try {
+      const params = new URLSearchParams({
+        fields: "id,name,type,size,modified_at",
+        limit: "1000",
+        offset: offsetStr ?? "0"
+      });
+      const res = await this.apiRequest(
+        `${FOLDERS_URL}/${folderId}/items?${params.toString()}`,
+        { method: "GET" }
+      );
+      const data = await res.json();
+      const files = (data.entries ?? []).map(mapEntry2);
+      const off = Number(data.offset ?? offsetStr ?? 0);
+      const loaded = off + files.length;
+      const hasMore = loaded < (data.total_count ?? loaded);
+      const nextCursor = hasMore ? `${folderId}:${loaded}` : void 0;
+      return {
+        files,
+        hasMore,
+        ...nextCursor !== void 0 ? { cursor: nextCursor } : {}
+      };
+    } catch (err) {
+      this.emitter?.emit("box:error", {
+        error: err instanceof Error ? err : new Error(String(err)),
+        action: "loadMoreFiles"
+      });
+      throw err;
+    }
+  }
+  // ── File operations: download files ──
+  async downloadFiles(driveFiles) {
+    const results = [];
+    for (const driveFile of driveFiles) {
+      if (driveFile.isFolder) continue;
+      try {
+        const file = await this.downloadSingleFile(driveFile);
+        if (file) {
+          results.push(file);
+        }
+      } catch (err) {
+        this.emitter?.emit("box:error", {
+          error: err instanceof Error ? err : new Error(String(err)),
+          action: "downloadFiles"
+        });
+      }
+    }
+    return results;
+  }
+  // ── File operations: load all files in folder recursively ──
+  async loadAllFilesInFolder(folderId) {
+    const allFiles = [];
+    try {
+      const { files } = await this.loadFiles(folderId);
+      for (const file of files) {
+        if (file.isFolder) {
+          const nested = await this.loadAllFilesInFolder(file.id);
+          allFiles.push(...nested);
+        } else {
+          allFiles.push(file);
+        }
+      }
+      return allFiles;
+    } catch (err) {
+      this.emitter?.emit("box:error", {
+        error: err instanceof Error ? err : new Error(String(err)),
+        action: "loadAllFilesInFolder"
+      });
+      throw err;
+    }
+  }
+  // ── File operations: search ──
+  async searchFiles(query) {
+    try {
+      const params = new URLSearchParams({
+        query,
+        fields: "id,name,type,size,modified_at",
+        limit: "100"
+      });
+      const res = await this.apiRequest(
+        `${SEARCH_URL2}?${params.toString()}`,
+        { method: "GET" }
+      );
+      const data = await res.json();
+      const entries = data.entries ?? [];
+      return entries.map(mapEntry2);
+    } catch (err) {
+      this.emitter?.emit("box:error", {
+        error: err instanceof Error ? err : new Error(String(err)),
+        action: "searchFiles"
+      });
+      throw err;
+    }
+  }
+  // ── Provider hooks required by the base ──
+  mapEntry(entry) {
+    return mapEntry2(entry);
+  }
+  // ── Private: download a single file ──
+  async downloadSingleFile(driveFile) {
+    const res = await this.apiRequest(
+      `${FILES_URL2}/${driveFile.id}/content`,
+      { method: "GET" }
+    );
+    const blob = await res.blob();
+    return new File([blob], driveFile.name, {
+      type: blob.type || driveFile.mimeType || "application/octet-stream"
+    });
+  }
+  // ── Private: fetch user profile ──
+  async fetchUserProfile() {
+    const res = await this.apiRequest(USER_URL, { method: "GET" });
+    const data = await res.json();
+    return {
+      name: data.name ?? "",
+      email: data.login ?? ""
+    };
+  }
+};
+
+// src/drives/one-drive-plugin.ts
+var AUTH_URL3 = "https://login.microsoftonline.com/common/oauth2/v2.0/authorize";
+var TOKEN_URL3 = "https://login.microsoftonline.com/common/oauth2/v2.0/token";
+var GRAPH_BASE = "https://graph.microsoft.com/v1.0";
+var OAUTH_SCOPES2 = "user.read files.readwrite.all offline_access";
+var FILE_SELECT = "id,name,folder,file,size,@microsoft.graph.downloadUrl";
+var FILE_EXPAND = "thumbnails";
+function mapGraphItem(item) {
+  const isFolder = !!item.folder;
+  const file = item.file;
+  const mimeType = isFolder ? "folder" : file?.mimeType ?? guessMimeType(item.name);
+  const thumbnails = item.thumbnails;
+  let thumbnail;
+  if (thumbnails && thumbnails.length > 0) {
+    const thumbSet = thumbnails[0];
+    const medium = thumbSet?.medium;
+    thumbnail = medium?.url ?? void 0;
+  }
+  return {
+    id: item.id ?? "",
+    name: item.name ?? "",
+    path: item.id ?? "",
+    // OneDrive uses id-based navigation
+    size: isFolder ? 0 : item.size ?? 0,
+    mimeType,
+    isFolder,
+    thumbnail,
+    modifiedAt: item.lastModifiedDateTime ?? void 0
+  };
+}
+var OneDrivePlugin = class extends PopupOAuthPlugin {
+  constructor() {
+    super(...arguments);
+    this.spec = {
+      id: "one-drive",
+      displayName: "OneDrive",
+      eventPrefix: "one-drive",
+      popupName: "UpupOneDriveAuth",
+      authUrl: AUTH_URL3,
+      tokenUrl: TOKEN_URL3,
+      redirectPath: "/od_redirect",
+      storageKeys: {
+        access: "upup_one-drive_access_token",
+        refresh: "upup_one-drive_refresh_token",
+        expiry: "upup_one-drive_token_expiry"
+      },
+      scopes: OAUTH_SCOPES2,
+      authParams: { response_mode: "query" }
+    };
+  }
+  configure(config) {
+    return super.configure(config);
+  }
+  getConfig() {
+    return this.config;
+  }
+  // ── File operations: list files ──
+  async loadFiles(folderId) {
+    this.setState("browsing");
+    try {
+      const path = folderId ? `/me/drive/items/${folderId}/children` : "/me/drive/root/children";
+      const params = new URLSearchParams({
+        $select: FILE_SELECT,
+        $expand: FILE_EXPAND,
+        $top: "200"
+      });
+      const data = await this.graphRequest(`${path}?${params.toString()}`);
+      const items = Array.isArray(data.value) ? data.value : [];
+      const files = items.map(mapGraphItem);
+      const nextLink = data["@odata.nextLink"];
+      const hasMore = !!nextLink;
+      this.setState("authenticated");
+      this.emitter?.emit("one-drive:files-loaded", {
+        files,
+        folderId: folderId ?? "root",
+        hasMore,
+        cursor: nextLink
+      });
+      return {
+        files,
+        folderId: folderId ?? "root",
+        hasMore,
+        ...nextLink !== void 0 ? { cursor: nextLink } : {}
+      };
+    } catch (err) {
+      this.setState("authenticated");
+      this.emitter?.emit("one-drive:error", {
+        error: err instanceof Error ? err : new Error(String(err)),
+        action: "loadFiles"
+      });
+      throw err;
+    }
+  }
+  // ── File operations: continue listing (pagination) ──
+  async loadMoreFiles(cursor) {
+    try {
+      const data = await this.graphRequest(cursor);
+      const items = Array.isArray(data.value) ? data.value : [];
+      const files = items.map(mapGraphItem);
+      const nextLink = data["@odata.nextLink"];
+      return {
+        files,
+        hasMore: !!nextLink,
+        ...nextLink !== void 0 ? { cursor: nextLink } : {}
+      };
+    } catch (err) {
+      this.emitter?.emit("one-drive:error", {
+        error: err instanceof Error ? err : new Error(String(err)),
+        action: "loadMoreFiles"
+      });
+      throw err;
+    }
+  }
+  // ── File operations: download files ──
+  async downloadFiles(driveFiles) {
+    const results = [];
+    for (const driveFile of driveFiles) {
+      if (driveFile.isFolder) continue;
+      try {
+        const file = await this.downloadSingleFile(driveFile);
+        if (file) {
+          results.push(file);
+        }
+      } catch (err) {
+        this.emitter?.emit("one-drive:error", {
+          error: err instanceof Error ? err : new Error(String(err)),
+          action: "downloadFiles"
+        });
+      }
+    }
+    return results;
+  }
+  // ── File operations: load all files in folder recursively ──
+  async loadAllFilesInFolder(folderId) {
+    const allFiles = [];
+    try {
+      const { files } = await this.loadFiles(folderId);
+      for (const file of files) {
+        if (file.isFolder) {
+          const nested = await this.loadAllFilesInFolder(file.id);
+          allFiles.push(...nested);
+        } else {
+          allFiles.push(file);
+        }
+      }
+      return allFiles;
+    } catch (err) {
+      this.emitter?.emit("one-drive:error", {
+        error: err instanceof Error ? err : new Error(String(err)),
+        action: "loadAllFilesInFolder"
+      });
+      throw err;
+    }
+  }
+  // ── Provider hooks required by the base ──
+  mapEntry(entry) {
+    return mapGraphItem(entry);
+  }
+  // ── Private: fetch user profile (unguarded — called once tokens are set
+  // but before isAuthenticated() flips, and again via the public getUserInfo) ──
+  async fetchUserProfile() {
+    const data = await this.graphRequest("/me");
+    const displayName = data.displayName;
+    const mail = data.mail;
+    const userPrincipalName = data.userPrincipalName;
+    return {
+      name: typeof displayName === "string" ? displayName : "",
+      email: typeof mail === "string" ? mail : typeof userPrincipalName === "string" ? userPrincipalName : ""
+    };
+  }
+  // ── Private: Microsoft Graph API request (delegates auth/refresh/retry to
+  // the base apiRequest; returns parsed JSON, tolerating absolute URLs) ──
+  async graphRequest(path, options = {}) {
+    const url = path.startsWith("http") ? path : `${GRAPH_BASE}${path}`;
+    const res = await this.apiRequest(url, options);
+    return await res.json();
+  }
+  // ── Private: download a single file ──
+  async downloadSingleFile(driveFile) {
+    const itemData = await this.graphRequest(
+      `/me/drive/items/${driveFile.id}?select=@microsoft.graph.downloadUrl`
+    );
+    const downloadUrl = itemData["@microsoft.graph.downloadUrl"] ?? itemData["@content.downloadUrl"];
+    if (!downloadUrl) {
+      throw new UpupNetworkError(
+        `No download URL available for ${driveFile.name}`
+      );
+    }
+    const downloadRes = await fetch(downloadUrl, { method: "GET" });
+    if (!downloadRes.ok) {
+      throw new UpupNetworkError(
+        `Download failed (${downloadRes.status}) for ${driveFile.name}`,
+        downloadRes.status
+      );
+    }
+    const blob = await downloadRes.blob();
+    return new File([blob], driveFile.name, {
+      type: blob.type || driveFile.mimeType || "application/octet-stream"
+    });
+  }
+};
+
+// src/utils/accept-presets.ts
+var ACCEPT_PRESETS = {
+  images: {
+    label: "Images",
+    accept: "image/*"
+  },
+  video: {
+    label: "Video",
+    accept: "video/*"
+  },
+  audio: {
+    label: "Audio",
+    accept: "audio/*"
+  },
+  documents: {
+    label: "Documents",
+    accept: "application/pdf,application/msword,application/vnd.openxmlformats-officedocument.wordprocessingml.document,application/vnd.oasis.opendocument.text,text/plain,text/rtf"
+  },
+  spreadsheets: {
+    label: "Spreadsheets",
+    accept: "application/vnd.ms-excel,application/vnd.openxmlformats-officedocument.spreadsheetml.sheet,text/csv,application/vnd.oasis.opendocument.spreadsheet,.tsv"
+  },
+  presentations: {
+    label: "Presentations",
+    accept: "application/vnd.ms-powerpoint,application/vnd.openxmlformats-officedocument.presentationml.presentation,application/vnd.oasis.opendocument.presentation,.key"
+  },
+  archives: {
+    label: "Archives",
+    accept: "application/zip,application/x-rar-compressed,application/x-7z-compressed,application/x-tar,application/gzip,.bz2"
+  },
+  code: {
+    label: "Code",
+    accept: "text/javascript,application/json,text/html,text/css,text/xml,text/yaml,.ts,.tsx,.jsx,.py,.rb,.go,.rs,.java,.cpp,.c,.h,.sh,.sql"
+  },
+  fonts: {
+    label: "Fonts",
+    accept: "font/ttf,font/otf,font/woff,font/woff2,.ttf,.otf,.woff,.woff2"
+  },
+  "3d": {
+    label: "3D",
+    accept: ".obj,.stl,.gltf,.glb,.fbx,.usdz"
+  },
+  design: {
+    label: "Design",
+    accept: "image/svg+xml,.psd,.ai,.sketch,.fig,.xd"
+  },
+  ebooks: {
+    label: "Ebooks",
+    accept: "application/epub+zip,application/pdf,.mobi,.azw"
+  },
+  photography: {
+    label: "Photography",
+    accept: "image/*,.cr2,.cr3,.nef,.arw,.dng,.orf,.rw2,.raf,.raw"
+  },
+  animation: {
+    label: "Animation",
+    accept: "image/gif,image/apng,image/webp,.lottie,.rive"
+  },
+  ar: {
+    label: "AR",
+    accept: ".usdz,.reality,.glb,.gltf"
+  },
+  vector: {
+    label: "Vector",
+    accept: "image/svg+xml,.eps,.ai"
+  },
+  cad: {
+    label: "CAD",
+    accept: ".dwg,.dxf,.step,.stp,.iges,.igs"
+  },
+  gis: {
+    label: "GIS",
+    accept: "application/geo+json,.kml,.kmz,.shp,.gpx,.geojson"
+  },
+  data: {
+    label: "Data",
+    accept: "application/json,text/xml,text/csv,text/yaml,.toml,.parquet,.jsonl,.ndjson"
+  },
+  markup: {
+    label: "Markup",
+    accept: "text/markdown,.md,.rst,.tex,.adoc,.latex"
+  },
+  subtitles: {
+    label: "Subtitles",
+    accept: ".srt,.vtt,.ass,.sub,.ssa"
+  },
+  email: {
+    label: "Email",
+    accept: ".eml,.msg,.mbox"
+  },
+  calendar: {
+    label: "Calendar",
+    accept: "text/calendar,.ics,.ical"
+  },
+  contacts: {
+    label: "Contacts",
+    accept: "text/vcard,.vcf"
+  },
+  disk: {
+    label: "Disk",
+    accept: ".iso,.img,.dmg,.vhd,.vhdx"
+  },
+  ml: {
+    label: "ML",
+    accept: ".onnx,.h5,.pb,.pt,.safetensors,.pkl"
+  },
+  database: {
+    label: "Database",
+    accept: ".sql,.sqlite,.db,.mdb,.accdb"
+  },
+  certificates: {
+    label: "Certificates",
+    accept: ".pem,.crt,.cer,.p12,.pfx,.key"
+  },
+  firmware: {
+    label: "Firmware",
+    accept: ".bin,.hex,.elf,.srec"
+  },
+  executable: {
+    label: "Executable",
+    accept: ".exe,.msi,.dmg,.apk,.deb,.rpm,.appimage"
+  },
+  config: {
+    label: "Config",
+    accept: ".ini,.cfg,.conf,.env,.toml,.properties,.yaml,.yml"
+  },
+  financial: {
+    label: "Financial",
+    accept: ".ofx,.qfx,.qbo,.qif"
+  },
+  scientific: {
+    label: "Scientific",
+    accept: ".fits,.hdf5,.nc,.mat,.netcdf"
+  },
+  medical: {
+    label: "Medical",
+    accept: "application/dicom,.dcm,.nii,.nii.gz"
+  }
+};
+function resolveAccept(input) {
+  const raw = Array.isArray(input) ? input.join(",") : input;
+  return raw.split(",").map((token) => {
+    const trimmed = token.trim();
+    const key = trimmed.toLowerCase();
+    return ACCEPT_PRESETS[key]?.accept ?? trimmed;
+  }).join(",");
+}
+
+export { ACCEPT_PRESETS, BoxPlugin, CrashRecoveryManager, DropboxPlugin, EventEmitter, FileManager, GoogleDrivePlugin, IndexedDBStorage, OneDrivePlugin, PluginManager, PopupOAuthPlugin, UploadManager, isFileRemovalLocked, isUploadActive, isUploadIdle, resolveAccept, validateFileRestrictions };