deepspace 0.11.0 → 0.13.0

package/dist/index.d.ts

@@ -3636,6 +3636,12 @@ declare function toConnectionStatus(queryStatus: string): ConnectionStatus;
  *
  * Provides upload, download, list, and delete for files in R2.
  *
+ * Uploads pick their own transport. A small file goes in one request; a large
+ * one is chunked into parts with `Blob.slice`, so peak memory is bounded by
+ * the PART SIZE rather than by the file — a 1 GiB video costs one part, not a
+ * gibibyte — and the file ceiling becomes a product decision rather than a
+ * request-size accident. Callers do nothing differently either way.
+ *
  * Two scopes are supported via the `scope` option:
  *   - `'self'` (default): per-user storage. Reads require auth.
  *   - `'app'`: app-wide storage. Reads are public — the upload URL works
@@ -3668,10 +3674,29 @@ interface R2FileInfo {
     originalName?: string;
     uploadedBy?: string;
 }
+/** Told after each part lands, so a long upload can drive a progress bar. */
+type UploadProgress = (sent: number, total: number) => void;
+interface UploadOptions {
+    onProgress?: UploadProgress;
+}
 interface UseR2FilesReturn {
-    /** Upload a File or Blob. Optionally provide a display name. */
-    upload: (file: File | Blob, name?: string) => Promise<R2UploadResult>;
-    /** Upload raw base64 data. */
+    /**
+     * Upload a File or Blob. Optionally provide a display name.
+     *
+     * A file above the single-request bound is chunked automatically and sent as
+     * parts — nothing to opt into, and nothing held in memory beyond one part.
+     * Pass `onProgress` to follow a large one.
+     */
+    upload: (file: File | Blob, name?: string, options?: UploadOptions) => Promise<R2UploadResult>;
+    /**
+     * Upload raw base64 data.
+     *
+     * Single-request only: base64 has to be materialized whole to be decoded, so
+     * this path keeps the one-request bound rather than the file ceiling — and
+     * because the request carries the ENCODED string, its real budget is
+     * `MAX_BASE64_UPLOAD_BYTES` (~18.75 MiB decoded), not the full 25 MiB. Send a
+     * Blob through `upload` for anything larger; it chunks.
+     */
     uploadBase64: (base64Data: string, name: string, mimeType?: string) => Promise<R2UploadResult>;
     /**
      * Delete a file. Accepts an R2FileInfo from `list()` or a raw key string.

package/dist/index.js

@@ -3519,14 +3519,128 @@ function toConnectionStatus(queryStatus) {
 
 // src/client/storage/useR2Files.ts
 import { useCallback as useCallback15, useState as useState13, useMemo as useMemo11 } from "react";
+
+// src/shared/app-files.ts
+var MAX_APP_FILE_BYTES = 1024 * 1024 * 1024;
+var MAX_UPLOAD_REQUEST_BYTES = 25 * 1024 * 1024;
+var UPLOAD_PART_BYTES = 20 * 1024 * 1024;
+var MAX_UPLOAD_PARTS = Math.ceil(MAX_APP_FILE_BYTES / UPLOAD_PART_BYTES);
+var MAX_BASE64_UPLOAD_BYTES = Math.floor(MAX_UPLOAD_REQUEST_BYTES * 3 / 4);
+function planUploadParts(totalBytes, partSize) {
+  const parts = [];
+  for (let start = 0; start < totalBytes; start += partSize) {
+    parts.push({
+      partNumber: parts.length + 1,
+      start,
+      end: Math.min(start + partSize, totalBytes)
+    });
+  }
+  return parts;
+}
+var MAX_DEPLOY_ASSET_FILE_BYTES = 25 * 1024 * 1024;
+function formatBytes(bytes) {
+  if (bytes >= 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GiB`;
+  if (bytes >= 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MiB`;
+  if (bytes >= 1024) return `${Math.round(bytes / 1024)} KiB`;
+  return `${bytes} B`;
+}
+function encodeKeyPath(key) {
+  return key.split("/").map(encodeURIComponent).join("/");
+}
+function oversizeMessage(bytes, limit = MAX_APP_FILE_BYTES) {
+  return `That file is ${formatBytes(bytes)}; the limit is ${formatBytes(limit)} per file.`;
+}
+function describeFilesFailure(status, body) {
+  const trimmed = body.trim();
+  if (trimmed.startsWith("{")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed.error) return parsed.error;
+    } catch {
+    }
+  }
+  if (status === 413) {
+    return `The upload is too large. Files are limited to ${formatBytes(MAX_APP_FILE_BYTES)}, and one request may carry ${formatBytes(MAX_UPLOAD_REQUEST_BYTES)} \u2014 a larger request is rejected by the network before the app receives it.`;
+  }
+  if (status === 411) return "The upload did not declare its length.";
+  if (status === 401 || status === 403) return "Not authorized to write these files.";
+  if (status === 415) return "That file type is not accepted.";
+  if (status >= 500) return `The files service failed (HTTP ${status}). Retry shortly.`;
+  return `Upload failed (HTTP ${status}).`;
+}
+
+// src/client/storage/useR2Files.ts
+function oversize(bytes, limit = MAX_APP_FILE_BYTES) {
+  return bytes > limit ? { success: false, error: oversizeMessage(bytes, limit) } : null;
+}
+async function readUploadResult(response) {
+  const text = await response.text();
+  if (response.ok) {
+    try {
+      return JSON.parse(text);
+    } catch {
+      return { success: false, error: "The files service returned a malformed response." };
+    }
+  }
+  return { success: false, error: describeFilesFailure(response.status, text) };
+}
 function resolveFile(fileOrKey) {
   if (typeof fileOrKey === "string") {
     return { key: fileOrKey, name: void 0 };
   }
   return { key: fileOrKey.key, name: fileOrKey.originalName };
 }
-function encodeKeyPath(key) {
-  return key.split("/").map(encodeURIComponent).join("/");
+async function uploadInParts(file, name, scopeParams, authHeaders, onProgress) {
+  const headers = await authHeaders();
+  const json = { ...headers, "Content-Type": "application/json" };
+  const initResponse = await fetch(`/api/files/multipart?${scopeParams}`, {
+    method: "POST",
+    headers: json,
+    body: JSON.stringify({ name, mimeType: file.type || "application/octet-stream", size: file.size })
+  });
+  if (!initResponse.ok) return await readUploadResult(initResponse);
+  const session = await initResponse.json();
+  if (!Number.isSafeInteger(session.partSize) || session.partSize < 1) {
+    return {
+      success: false,
+      error: `The files service advertised an unusable part size (${session.partSize}).`
+    };
+  }
+  const query = `${scopeParams}&uploadKey=${encodeKeyPath(session.uploadKey)}&uploadId=${encodeURIComponent(session.uploadId)}`;
+  const plan = planUploadParts(file.size, session.partSize);
+  const parts = [];
+  let assembled = false;
+  try {
+    for (const part of plan) {
+      const send = () => fetch(`/api/files/multipart/part?${query}&partNumber=${part.partNumber}`, {
+        method: "PUT",
+        headers,
+        body: file.slice(part.start, part.end)
+      });
+      let response = await send().catch(() => null);
+      if (!response || response.status === 429 || response.status >= 500) {
+        const retried = await send().catch(() => null);
+        if (retried) response = retried;
+      }
+      if (!response) return { success: false, error: "The files service could not be reached." };
+      if (!response.ok) return await readUploadResult(response);
+      parts.push(await response.json());
+      onProgress?.(part.end, file.size);
+    }
+    const completed = await fetch(`/api/files/multipart/complete?${query}`, {
+      method: "POST",
+      headers: json,
+      body: JSON.stringify({ parts })
+    });
+    assembled = completed.ok;
+    return await readUploadResult(completed);
+  } finally {
+    if (!assembled) {
+      await fetch(`/api/files/multipart?${query}`, { method: "DELETE", headers }).catch(
+        () => void 0
+      );
+    }
+  }
 }
 function useR2Files(options) {
   const [isUploading, setIsUploading] = useState13(false);
@@ -3544,9 +3658,15 @@ function useR2Files(options) {
     return {};
   }, []);
   const upload = useCallback15(
-    async (file, name) => {
+    async (file, name, options2) => {
       setIsUploading(true);
       try {
+        const tooBig = oversize(file.size);
+        if (tooBig) return tooBig;
+        const fileName = name ?? (file instanceof File ? file.name : "upload");
+        if (file.size > UPLOAD_PART_BYTES) {
+          return await uploadInParts(file, fileName, scopeParams, authHeaders, options2?.onProgress);
+        }
         const headers = await authHeaders();
         const formData = new FormData();
         formData.append("file", file);
@@ -3556,7 +3676,8 @@ function useR2Files(options) {
           headers,
           body: formData
         });
-        return await response.json();
+        options2?.onProgress?.(file.size, file.size);
+        return await readUploadResult(response);
       } catch (err) {
         return { success: false, error: err instanceof Error ? err.message : "Upload failed" };
       } finally {
@@ -3569,13 +3690,18 @@ function useR2Files(options) {
     async (base64Data, name, mimeType) => {
       setIsUploading(true);
       try {
+        const tooBig = oversize(
+          Math.floor(base64Data.length * 3 / 4),
+          MAX_BASE64_UPLOAD_BYTES
+        );
+        if (tooBig) return tooBig;
         const headers = await authHeaders();
         const response = await fetch(`/api/files/upload?${scopeParams}`, {
           method: "POST",
           headers: { ...headers, "Content-Type": "application/json" },
           body: JSON.stringify({ data: base64Data, name, mimeType })
         });
-        return await response.json();
+        return await readUploadResult(response);
       } catch (err) {
         return { success: false, error: err instanceof Error ? err.message : "Upload failed" };
       } finally {