@muhgholy/next-drive 4.23.32 → 4.23.34

package/README.md

@@ -446,7 +446,7 @@ const url = driveGetUrl(fileId, { expiry: new Date("2026-12-31") });
 ### Read File Stream
 
 ```typescript
-import { driveReadFile } from "@muhgholy/next-drive/server";
+import { driveReadFile, DriveError } from "@muhgholy/next-drive/server";
 
 // Using file ID
 const { stream, mime, size } = await driveReadFile(fileId);
@@ -455,6 +455,27 @@ stream.pipe(response);
 // Using database document
 const drive = await Drive.findById(fileId);
 const { stream, mime, size } = await driveReadFile(drive);
+
+// With progress and abort
+const controller = new AbortController();
+const { stream } = await driveReadFile(fileId, {
+  onProgress: ({ bytesDownloaded, totalBytes, percentage }) => {
+    console.log(`${percentage}% (${bytesDownloaded}/${totalBytes} bytes)`);
+  },
+  signal: controller.signal,
+});
+
+// onProgress fires for bytes piped through the returned stream - works the same way
+// whether the file is local or on Google Drive, and whether it's already cached or not.
+// Aborting destroys the stream and emits an 'error' event with a DriveError (code: 'ABORTED').
+stream.on("error", (err) => {
+  if (err instanceof DriveError && err.code === "ABORTED") {
+    console.log("Read aborted");
+  }
+});
+
+// Somewhere else:
+controller.abort();
 ```
 
 ### Get File/Folder Information
@@ -496,7 +517,7 @@ const info = await driveInfo(file);
 For libraries requiring file paths (Sharp, FFmpeg, etc.):
 
 ```typescript
-import { driveFilePath } from "@muhgholy/next-drive/server";
+import { driveFilePath, DriveError } from "@muhgholy/next-drive/server";
 
 const { path, mime, size, provider } = await driveFilePath(fileId);
 
@@ -505,9 +526,64 @@ await sharp(path).resize(800, 600).toFile("output.jpg");
 
 // Use with FFmpeg
 await ffmpeg(path).format("mp4").save("output.mp4");
+
+// With progress and abort (only relevant for a Google Drive cache-miss download - local files
+// and already-cached Google Drive files resolve instantly and never call onProgress)
+const controller = new AbortController();
+try {
+  const result = await driveFilePath(fileId, {
+    onProgress: ({ bytesDownloaded, totalBytes, percentage }) => {
+      console.log(`${percentage}% (${bytesDownloaded}/${totalBytes} bytes)`);
+    },
+    signal: controller.signal,
+  });
+} catch (err) {
+  if (err instanceof DriveError && err.code === "ABORTED") {
+    console.log("Download aborted");
+  }
+}
+
+// Somewhere else:
+controller.abort();
+```
+
+> Google Drive files are automatically downloaded to local cache. Concurrent calls for the same
+> file are deduplicated - only one download happens, and every caller's `onProgress` receives the
+> same progress events.
+
+### Error Handling
+
+Every error thrown directly by the server controllers (`driveReadFile`, `driveFilePath`,
+`driveList`, `driveUpload`, `driveDelete`, etc.) is a `DriveError` with a `code` you can match on
+instead of parsing the message text:
+
+```typescript
+import { DriveError } from "@muhgholy/next-drive/server";
+
+try {
+  await driveFilePath(fileId);
+} catch (err) {
+  if (err instanceof DriveError) {
+    switch (err.code) {
+      case "NOT_FOUND":
+        // file no longer exists
+        break;
+      case "ABORTED":
+        // caller-triggered abort via AbortSignal
+        break;
+      case "ACCESS_DENIED":
+      case "QUOTA_EXCEEDED":
+      case "FILE_TOO_LARGE":
+        // ...handle other codes
+        break;
+    }
+  }
+}
 ```
 
-> Google Drive files are automatically downloaded to local cache.
+`TDriveErrorCode` includes: `NOT_FOUND`, `INVALID_REFERENCE`, `INVALID_TYPE`, `FILE_MISSING`,
+`UNSUPPORTED_PROVIDER`, `ACCESS_DENIED`, `FOLDER_NOT_EMPTY`, `INVALID_PATH`, `INVALID_MIME_TYPE`,
+`FILE_TOO_LARGE`, `QUOTA_EXCEEDED`, `MAX_DEPTH_EXCEEDED`, `ABORTED`, `DOWNLOAD_FAILED`.
 
 ### List Files and Folders
 

package/dist/{chunk-HWNIRA6Y.cjs → chunk-DHIHCER6.cjs}

@@ -517,6 +517,15 @@ var getImageSettings = (fileSizeInBytes, qualityPreset, display, size, fit, posi
     ...resolvedPosition && { position: resolvedPosition }
   };
 };
+
+// src/server/errors.ts
+var DriveError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.name = "DriveError";
+    this.code = code;
+  }
+};
 var generatePlaceholderThumbnail = async (outputPath, mimeType) => {
   const typeParts = mimeType.split("/");
   const subtype = typeParts[1] || "file";
@@ -973,7 +982,7 @@ var GoogleDriveProvider = {
       return { usedInBytes: 0, quotaInBytes: 0 };
     }
   },
-  openStream: async (item, accountId) => {
+  openStream: async (item, accountId, options) => {
     if (item.information.type === "FOLDER") throw new Error("Could not open Google Drive file: folders cannot be streamed");
     const cachePath = path__default.default.join(getDriveConfig().storage.path, "file", item._id.toString(), "data.bin");
     if (fs__default.default.existsSync(cachePath)) {
@@ -990,24 +999,36 @@ var GoogleDriveProvider = {
       { fileId: item.provider.google.id, alt: "media" },
       { responseType: "stream" }
     );
-    const fileDir = path__default.default.dirname(cachePath);
-    if (!fs__default.default.existsSync(fileDir)) fs__default.default.mkdirSync(fileDir, { recursive: true });
-    const tempPath = `${cachePath}.tmp`;
-    const writeStream = fs__default.default.createWriteStream(tempPath);
-    res.data.pipe(writeStream);
-    writeStream.on("finish", () => {
-      try {
-        fs__default.default.renameSync(tempPath, cachePath);
-      } catch {
-        fs__default.default.unlinkSync(tempPath);
-      }
-    });
-    writeStream.on("error", () => fs__default.default.unlink(tempPath, () => {
-    }));
+    let cacheWritePromise;
+    if (!options?.skipCache) {
+      const fileDir = path__default.default.dirname(cachePath);
+      if (!fs__default.default.existsSync(fileDir)) fs__default.default.mkdirSync(fileDir, { recursive: true });
+      const tempPath = `${cachePath}.tmp`;
+      const writeStream = fs__default.default.createWriteStream(tempPath);
+      res.data.pipe(writeStream);
+      cacheWritePromise = new Promise((resolve, reject) => {
+        writeStream.on("finish", () => {
+          try {
+            fs__default.default.renameSync(tempPath, cachePath);
+            resolve();
+          } catch {
+            fs__default.default.unlink(tempPath, () => {
+            });
+            reject(new Error("Could not cache Google Drive file: failed to finalize the cached file"));
+          }
+        });
+        writeStream.on("error", (err) => {
+          fs__default.default.unlink(tempPath, () => {
+          });
+          reject(err);
+        });
+      });
+    }
     return {
       stream: res.data,
       mime: item.information.mime,
-      size: item.information.sizeInBytes
+      size: item.information.sizeInBytes,
+      cacheWritePromise
     };
   },
   getThumbnail: async (item, accountId) => {
@@ -1271,28 +1292,44 @@ var driveAddSignedUrlToken = (item, config) => {
 var driveAddSignedUrlTokens = (items, config) => {
   return items.map((item) => driveAddSignedUrlToken(item, config));
 };
-var driveReadFile = async (file) => {
+var driveReadFile = async (file, options) => {
   let drive;
   if (typeof file === "string") {
     const doc = await drive_default.findById(file);
-    if (!doc) throw new Error("Could not read file: the file no longer exists");
+    if (!doc) throw new DriveError("NOT_FOUND", "Could not read file: the file no longer exists");
     drive = doc;
   } else if ("toClient" in file) {
     drive = file;
   } else {
-    throw new Error("Could not read file: invalid file reference provided");
+    throw new DriveError("INVALID_REFERENCE", "Could not read file: invalid file reference provided");
   }
   if (drive.information.type !== "FILE") {
-    throw new Error("Could not read file: this item is a folder, not a file");
+    throw new DriveError("INVALID_TYPE", "Could not read file: this item is a folder, not a file");
   }
   const provider = drive.provider?.type === "GOOGLE" ? GoogleDriveProvider : LocalStorageProvider;
   const accountId = drive.storageAccountId?.toString();
-  return await provider.openStream(drive, accountId);
+  const driveId = String(drive._id);
+  let result;
+  if (provider === GoogleDriveProvider && cacheWriteLocks.has(driveId)) {
+    result = await provider.openStream(drive, accountId, { skipCache: true });
+  } else {
+    result = await provider.openStream(drive, accountId);
+    if (result.cacheWritePromise) {
+      const cacheWritePromise = result.cacheWritePromise;
+      cacheWritePromise.catch(() => {
+      });
+      cacheWriteLocks.set(driveId, cacheWritePromise);
+      cacheWritePromise.finally(() => {
+        if (cacheWriteLocks.get(driveId) === cacheWritePromise) cacheWriteLocks.delete(driveId);
+      });
+    }
+  }
+  return { ...result, stream: instrumentReadableForProgress(result.stream, result.size, options) };
 };
 var driveInfo = async (source) => {
   const fileId = typeof source === "string" ? source : source.id;
   const drive = await drive_default.findById(fileId);
-  if (!drive) throw new Error("Could not load file details: the file no longer exists");
+  if (!drive) throw new DriveError("NOT_FOUND", "Could not load file details: the file no longer exists");
   let parentName;
   if (drive.parentId) {
     const parent = await drive_default.findById(drive.parentId);
@@ -1327,19 +1364,107 @@ var driveInfo = async (source) => {
   }
   return info;
 };
-var driveFilePath = async (file) => {
+var computeTransferPercentage = (bytesDownloaded, totalBytes) => {
+  if (!totalBytes) return 0;
+  return Math.min(100, Math.round(bytesDownloaded / totalBytes * 100));
+};
+var cacheWriteLocks = /* @__PURE__ */ new Map();
+var inFlightGoogleDownloads = /* @__PURE__ */ new Map();
+var downloadGoogleFileToCache = async (drive, accountId, cachePath, totalBytes, listeners, controller) => {
+  if (controller.signal.aborted) {
+    throw new DriveError("ABORTED", "Could not download file: the download was aborted");
+  }
+  const { stream } = await GoogleDriveProvider.openStream(drive, accountId, { skipCache: true });
+  if (controller.signal.aborted) {
+    stream.destroy();
+    throw new DriveError("ABORTED", "Could not download file: the download was aborted");
+  }
+  const fileDir = path__default.default.dirname(cachePath);
+  if (!fs__default.default.existsSync(fileDir)) fs__default.default.mkdirSync(fileDir, { recursive: true });
+  const tempPath = `${cachePath}.tmp`;
+  const writeStream = fs__default.default.createWriteStream(tempPath);
+  const cleanupTempFile = () => fs__default.default.unlink(tempPath, () => {
+  });
+  const onAbort = () => {
+    const abortError = new DriveError("ABORTED", "Could not download file: the download was aborted");
+    stream.destroy(abortError);
+    writeStream.destroy(abortError);
+  };
+  controller.signal.addEventListener("abort", onAbort, { once: true });
+  try {
+    let bytesDownloaded = 0;
+    await new Promise((resolve, reject) => {
+      stream.on("data", (chunk) => {
+        bytesDownloaded += chunk.length;
+        const info = {
+          bytesDownloaded,
+          totalBytes,
+          percentage: computeTransferPercentage(bytesDownloaded, totalBytes)
+        };
+        for (const listener of listeners) listener(info);
+      });
+      stream.pipe(writeStream);
+      writeStream.on("finish", resolve);
+      writeStream.on("error", reject);
+      stream.on("error", reject);
+    });
+  } catch (err) {
+    cleanupTempFile();
+    if (controller.signal.aborted) {
+      throw new DriveError("ABORTED", "Could not download file: the download was aborted");
+    }
+    throw new DriveError("DOWNLOAD_FAILED", `Could not download file: ${err instanceof Error ? err.message : "an unknown error occurred"}`);
+  } finally {
+    controller.signal.removeEventListener("abort", onAbort);
+  }
+  try {
+    fs__default.default.renameSync(tempPath, cachePath);
+  } catch (err) {
+    if (err instanceof Error && "code" in err && err.code === "EXDEV") {
+      fs__default.default.copyFileSync(tempPath, cachePath);
+      fs__default.default.unlinkSync(tempPath);
+    } else {
+      cleanupTempFile();
+      throw new DriveError("DOWNLOAD_FAILED", "Could not download file: failed to finalize the cached file");
+    }
+  }
+};
+var instrumentReadableForProgress = (source, totalBytes, options) => {
+  if (!options?.onProgress && !options?.signal) return source;
+  const passThrough = new stream.PassThrough();
+  let bytesDownloaded = 0;
+  source.on("data", (chunk) => {
+    bytesDownloaded += chunk.length;
+    options.onProgress?.({
+      bytesDownloaded,
+      totalBytes,
+      percentage: computeTransferPercentage(bytesDownloaded, totalBytes)
+    });
+  });
+  source.on("error", (err) => passThrough.destroy(err));
+  source.pipe(passThrough);
+  if (options.signal) {
+    const onAbort = () => {
+      source.destroy(new DriveError("ABORTED", "Could not read file: the read was aborted"));
+    };
+    if (options.signal.aborted) onAbort();
+    else options.signal.addEventListener("abort", onAbort, { once: true });
+  }
+  return passThrough;
+};
+var driveFilePath = async (file, options) => {
   let drive;
   if (typeof file === "string") {
     const doc = await drive_default.findById(file);
-    if (!doc) throw new Error("Could not locate file: the file no longer exists");
+    if (!doc) throw new DriveError("NOT_FOUND", "Could not locate file: the file no longer exists");
     drive = doc;
   } else if ("toClient" in file) {
     drive = file;
   } else {
-    throw new Error("Could not locate file: invalid file reference provided");
+    throw new DriveError("INVALID_REFERENCE", "Could not locate file: invalid file reference provided");
   }
   if (drive.information.type !== "FILE") {
-    throw new Error("Could not locate file: this item is a folder, not a file");
+    throw new DriveError("INVALID_TYPE", "Could not locate file: this item is a folder, not a file");
   }
   const config = getDriveConfig();
   const STORAGE_PATH = config.storage.path;
@@ -1347,7 +1472,7 @@ var driveFilePath = async (file) => {
   if (providerType === "LOCAL") {
     const filePath = path__default.default.join(STORAGE_PATH, "file", String(drive._id), "data.bin");
     if (!fs__default.default.existsSync(filePath)) {
-      throw new Error("Could not locate file: the stored file is missing from disk");
+      throw new DriveError("FILE_MISSING", "Could not locate file: the stored file is missing from disk");
     }
     return Object.freeze({
       path: filePath,
@@ -1358,11 +1483,34 @@ var driveFilePath = async (file) => {
     });
   }
   if (providerType === "GOOGLE") {
-    const fileDir = path__default.default.join(STORAGE_PATH, "file", String(drive._id));
+    const driveId = String(drive._id);
+    const fileDir = path__default.default.join(STORAGE_PATH, "file", driveId);
     const cachedFilePath = path__default.default.join(fileDir, "data.bin");
+    const expectedSize = drive.information.sizeInBytes;
+    const isCached = () => {
+      if (!fs__default.default.existsSync(cachedFilePath)) return false;
+      return fs__default.default.statSync(cachedFilePath).size === expectedSize;
+    };
+    if (isCached()) {
+      return Object.freeze({
+        path: cachedFilePath,
+        name: drive.name,
+        mime: drive.information.mime,
+        size: drive.information.sizeInBytes,
+        provider: "GOOGLE"
+      });
+    }
     if (fs__default.default.existsSync(cachedFilePath)) {
-      const stats = fs__default.default.statSync(cachedFilePath);
-      if (stats.size === drive.information.sizeInBytes) {
+      fs__default.default.unlinkSync(cachedFilePath);
+    }
+    const accountId = drive.storageAccountId?.toString();
+    const existingLock = cacheWriteLocks.get(driveId);
+    if (existingLock) {
+      try {
+        await existingLock;
+      } catch {
+      }
+      if (isCached()) {
         return Object.freeze({
           path: cachedFilePath,
           name: drive.name,
@@ -1371,31 +1519,26 @@ var driveFilePath = async (file) => {
           provider: "GOOGLE"
         });
       }
-      fs__default.default.unlinkSync(cachedFilePath);
     }
-    const accountId = drive.storageAccountId?.toString();
-    const { stream } = await GoogleDriveProvider.openStream(drive, accountId);
-    if (!fs__default.default.existsSync(fileDir)) {
-      fs__default.default.mkdirSync(fileDir, { recursive: true });
+    let entry = inFlightGoogleDownloads.get(driveId);
+    if (!entry) {
+      const controller = new AbortController();
+      const listeners = /* @__PURE__ */ new Set();
+      const promise = downloadGoogleFileToCache(drive, accountId, cachedFilePath, expectedSize, listeners, controller).finally(() => {
+        inFlightGoogleDownloads.delete(driveId);
+        if (cacheWriteLocks.get(driveId) === promise) cacheWriteLocks.delete(driveId);
+      });
+      entry = { promise, controller, listeners };
+      inFlightGoogleDownloads.set(driveId, entry);
+      cacheWriteLocks.set(driveId, promise);
     }
-    const tempPath = `${cachedFilePath}.tmp`;
-    const writeStream = fs__default.default.createWriteStream(tempPath);
-    await new Promise((resolve, reject) => {
-      stream.pipe(writeStream);
-      writeStream.on("finish", resolve);
-      writeStream.on("error", reject);
-      stream.on("error", reject);
-    });
-    try {
-      fs__default.default.renameSync(tempPath, cachedFilePath);
-    } catch (err) {
-      if (err instanceof Error && "code" in err && err.code === "EXDEV") {
-        fs__default.default.copyFileSync(tempPath, cachedFilePath);
-        fs__default.default.unlinkSync(tempPath);
-      } else {
-        throw err;
-      }
+    const activeEntry = entry;
+    if (options?.onProgress) activeEntry.listeners.add(options.onProgress);
+    if (options?.signal) {
+      if (options.signal.aborted) activeEntry.controller.abort();
+      else options.signal.addEventListener("abort", () => activeEntry.controller.abort(), { once: true });
     }
+    await activeEntry.promise;
     return Object.freeze({
       path: cachedFilePath,
       name: drive.name,
@@ -1404,7 +1547,7 @@ var driveFilePath = async (file) => {
       provider: "GOOGLE"
     });
   }
-  throw new Error(`Could not locate file: unsupported storage provider "${providerType}"`);
+  throw new DriveError("UNSUPPORTED_PROVIDER", `Could not locate file: unsupported storage provider "${providerType}"`);
 };
 var driveList = async (options) => {
   const { key, folderId, accountId, limit = 100, afterId } = options;
@@ -1412,7 +1555,7 @@ var driveList = async (options) => {
   if (accountId && accountId !== "LOCAL") {
     const account = await drive_default.db.model("StorageAccount").findOne({ _id: accountId, owner: key });
     if (!account) {
-      throw new Error("Could not list files: storage account not found or access denied");
+      throw new DriveError("ACCESS_DENIED", "Could not list files: storage account not found or access denied");
     }
     if (account.metadata.provider === "GOOGLE") {
       providerName = "GOOGLE";
@@ -1440,7 +1583,7 @@ var driveListFiles = async (options) => {
   if (accountId && accountId !== "LOCAL") {
     const account = await drive_default.db.model("StorageAccount").findOne({ _id: accountId, owner: key });
     if (!account) {
-      throw new Error("Could not load files: storage account not found or access denied");
+      throw new DriveError("ACCESS_DENIED", "Could not load files: storage account not found or access denied");
     }
     if (account.metadata.provider === "GOOGLE") {
       providerName = "GOOGLE";
@@ -1484,7 +1627,7 @@ var driveDelete = async (source, options) => {
   let driveId;
   if (typeof source === "string") {
     const doc = await drive_default.findById(source);
-    if (!doc) throw new Error("Could not delete: the file no longer exists");
+    if (!doc) throw new DriveError("NOT_FOUND", "Could not delete: the file no longer exists");
     drive = doc;
     driveId = source;
   } else if ("toClient" in source) {
@@ -1492,7 +1635,7 @@ var driveDelete = async (source, options) => {
     driveId = String(drive._id);
   } else {
     const doc = await drive_default.findById(source.id);
-    if (!doc) throw new Error("Could not delete: the selected file no longer exists");
+    if (!doc) throw new DriveError("NOT_FOUND", "Could not delete: the selected file no longer exists");
     drive = doc;
     driveId = source.id;
   }
@@ -1504,7 +1647,7 @@ var driveDelete = async (source, options) => {
       trashedAt: null
     });
     if (childCount > 0) {
-      throw new Error(`Could not delete folder: it still contains ${childCount} item(s). Enable recursive delete to remove the folder and everything inside it.`);
+      throw new DriveError("FOLDER_NOT_EMPTY", `Could not delete folder: it still contains ${childCount} item(s). Enable recursive delete to remove the folder and everything inside it.`);
     }
   }
   const provider = drive.provider?.type === "GOOGLE" ? GoogleDriveProvider : LocalStorageProvider;
@@ -1515,17 +1658,17 @@ var driveDelete = async (source, options) => {
 var resolveFolderByPath = async (folderPath, owner, accountId) => {
   const normalizedPath = folderPath.replace(/^\/+|\/+$/g, "");
   if (!normalizedPath) {
-    throw new Error("Could not resolve folder: the folder path is empty");
+    throw new DriveError("INVALID_PATH", "Could not resolve folder: the folder path is empty");
   }
   const segments = normalizedPath.split("/").filter((s) => s.length > 0);
   if (segments.length === 0) {
-    throw new Error("Could not resolve folder: the folder path is invalid");
+    throw new DriveError("INVALID_PATH", "Could not resolve folder: the folder path is invalid");
   }
   let providerName = "LOCAL";
   if (accountId && accountId !== "LOCAL") {
     const account = await drive_default.db.model("StorageAccount").findOne({ _id: accountId, owner });
     if (!account) {
-      throw new Error("Could not resolve folder: storage account not found or access denied");
+      throw new DriveError("ACCESS_DENIED", "Could not resolve folder: storage account not found or access denied");
     }
     if (account.metadata.provider === "GOOGLE") {
       providerName = "GOOGLE";
@@ -1559,7 +1702,7 @@ var driveUpload = async (source, key, options) => {
   if (accountId && accountId !== "LOCAL") {
     const account = await drive_default.db.model("StorageAccount").findOne({ _id: accountId, owner: key });
     if (!account) {
-      throw new Error("Could not upload: storage account not found or access denied");
+      throw new DriveError("ACCESS_DENIED", "Could not upload: storage account not found or access denied");
     }
     if (account.metadata.provider === "GOOGLE") {
       provider = GoogleDriveProvider;
@@ -1570,7 +1713,7 @@ var driveUpload = async (source, key, options) => {
   let fileSize;
   if (typeof source === "string") {
     if (!fs__default.default.existsSync(source)) {
-      throw new Error("Could not upload: source file not found");
+      throw new DriveError("FILE_MISSING", "Could not upload: source file not found");
     }
     sourceFilePath = source;
     const stats = fs__default.default.statSync(source);
@@ -1629,17 +1772,17 @@ var driveUpload = async (source, key, options) => {
       mimeType = mimeTypes[ext] || "application/octet-stream";
     }
     if (config.security && !validateMimeType(mimeType, config.security.allowedMimeTypes)) {
-      throw new Error(`Could not upload: file type "${mimeType}" is not allowed`);
+      throw new DriveError("INVALID_MIME_TYPE", `Could not upload: file type "${mimeType}" is not allowed`);
     }
     if (config.security && fileSize > config.security.maxUploadSizeInBytes) {
-      throw new Error("Could not upload: file is larger than the maximum allowed size");
+      throw new DriveError("FILE_TOO_LARGE", "Could not upload: file is larger than the maximum allowed size");
     }
     const isRootMode = config.mode === "ROOT";
     if (!options.enforce && !isRootMode) {
       const information = await getDriveInformation({ method: "KEY", key });
       const quota = await provider.getQuota(key, accountId, information.storage.quotaInBytes);
       if (quota.usedInBytes + fileSize > quota.quotaInBytes) {
-        throw new Error("Could not upload: you have run out of storage space");
+        throw new DriveError("QUOTA_EXCEEDED", "Could not upload: you have run out of storage space");
       }
     }
     let resolvedParentId = null;
@@ -1751,7 +1894,7 @@ var driveCleanup = async () => {
     }
   }
   try {
-    const { getTusServer: getTusServer2 } = await import('./tus-5LLFMVQK.cjs');
+    const { getTusServer: getTusServer2 } = await import('./tus-EQ2IXSRE.cjs');
     await getTusServer2().cleanUpExpiredUploads();
   } catch (e) {
     console.error("[next-drive] Failed to clean up expired tus uploads:", e);
@@ -1840,8 +1983,13 @@ var getTusServer = () => {
       if (!ctx) return Number.MAX_SAFE_INTEGER;
       return ctx.authenticated ? ctx.config.security?.maxUploadSizeInBytes ?? Number.MAX_SAFE_INTEGER : ctx.config.security?.unauthenticated?.maxUploadSizeInBytes ?? 0;
     },
-    // ** Keep the upload id in the query string so every method stays on `?action=upload`.
-    generateUrl: (_req, { path: p, id }) => `${p}?action=upload&id=${id}`,
+    // ** Keep the upload id in the query string so every method stays on `?action=upload`. Derive
+    // ** the path from the ACTUAL incoming request rather than the static `apiPath` this server was
+    // ** constructed with - the two can drift apart (config.apiUrl is frozen on `globalThis` for the
+    // ** life of the process, see getTusServer() above, so it can go stale after a proxy/route change
+    // ** without a full restart). Mirroring the request's own path makes the continuation URL always
+    // ** match wherever the client actually is, regardless of what `apiUrl` was configured with.
+    generateUrl: (req, { id }) => `${new URL(req.url).pathname}?action=upload&id=${id}`,
     // ** SECURITY: the id becomes a filesystem path inside FileStore (fs.unlink/read/resolve), and it
     // ** arrives from the client-controlled query string. Only accept the exact format our
     // ** namingFunction produces (32 lowercase hex) so a crafted `?id=../../..` cannot traverse out
@@ -1996,6 +2144,7 @@ var handleUpload = async (req, res, ctx) => {
   res.end(response.body ? Buffer.from(await response.arrayBuffer()) : void 0);
 };
 
+exports.DriveError = DriveError;
 exports.GoogleDriveProvider = GoogleDriveProvider;
 exports.LocalStorageProvider = LocalStorageProvider;
 exports.account_default = account_default;
@@ -2021,5 +2170,5 @@ exports.resolveProvider = resolveProvider;
 exports.resolveTusCorsOptions = resolveTusCorsOptions;
 exports.withSignedUrl = withSignedUrl;
 exports.withSignedUrls = withSignedUrls;
-//# sourceMappingURL=chunk-HWNIRA6Y.cjs.map
-//# sourceMappingURL=chunk-HWNIRA6Y.cjs.map
+//# sourceMappingURL=chunk-DHIHCER6.cjs.map
+//# sourceMappingURL=chunk-DHIHCER6.cjs.map